khanat-opennel-code/code/nel/src/3d/ps_tail_dot.cpp

600 lines
16 KiB
C++
Raw Normal View 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/ps_tail_dot.h"
#include "nel/3d/ps_macro.h"
#include "nel/3d/driver.h"
#include "nel/3d/particle_system.h"
#include "nel/3d/texture_mem.h"
#include "nel/misc/smart_ptr.h"
#include <memory>
namespace NL3D
{
static NLMISC::CRGBA GradientB2W[] = {NLMISC::CRGBA(0, 0, 0, 0), NLMISC::CRGBA(255, 255, 255, 255) };
/// private use : this create a gradient texture that goew from black to white
static ITexture *CreateGradientTexture()
{
NL_PS_FUNC(CreateGradientTexture)
std::auto_ptr<CTextureMem> tex(new CTextureMem((uint8 *) &GradientB2W,
sizeof(GradientB2W),
false, /* dont delete */
false, /* not a file */
2, 1)
);
tex->setWrapS(ITexture::Clamp);
tex->setShareName("#GradBW");
return tex.release();
}
///////////////////////////////
// CPSTailDot implementation //
///////////////////////////////
CPSTailDot::TVBMap CPSTailDot::_VBMap; // index / vertex buffers with no color
CPSTailDot::TVBMap CPSTailDot::_FadedVBMap; // index / vertex buffers for constant color with fading
CPSTailDot::TVBMap CPSTailDot::_ColoredVBMap; // index / vertex buffer + colors
CPSTailDot::TVBMap CPSTailDot::_FadedColoredVBMap; // index / vertex buffer + faded colors
//=======================================================
CPSTailDot::CPSTailDot() : _ColorFading(false),
_GlobalColor(false),
_Lighted(false),
_ForceLighted(false),
_Touch(true)
{
NL_PS_FUNC(CPSTailDot_CPSTailDot)
setInterpolationMode(Linear);
setSegDuration(0.06f);
if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("TailDot");
}
//=======================================================
CPSTailDot::~CPSTailDot()
{
NL_PS_FUNC(CPSTailDot_CPSTailDotDtor)
// delete _DyingRibbons;
}
//=======================================================
void CPSTailDot::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
NL_PS_FUNC(CPSTailDot_serial)
sint ver = f.serialVersion(3);
if (ver == 1)
{
nlassert(f.isReading());
/// we had CPSParticle::serial(f), but this is not the base class anymore, so we emulate this...
/// version 2 : auto-lod saved
sint ver2 = f.serialVersion(2);
// here is CPSLocatedBindable::serial(f)
sint ver3 = f.serialVersion(4);
f.serialPtr(_Owner);
if (ver3 > 1) f.serialEnum(_LOD);
if (ver3 > 2) f.serial(_Name);
if (ver3 > 3)
{
if (f.isReading())
{
uint32 id;
f.serial(id);
setExternID(id);
}
else
{
f.serial(_ExternID);
}
}
if (ver2 >= 2)
{
bool bDisableAutoLOD;
f.serial(bDisableAutoLOD);
disableAutoLOD(bDisableAutoLOD);
}
uint32 tailNbSegs;
bool colorFading;
bool systemBasisEnabled;
CPSColoredParticle::serialColorScheme(f);
f.serial(tailNbSegs, colorFading, systemBasisEnabled);
_ColorFading = colorFading;
_NbSegs = tailNbSegs >> 1;
if (_NbSegs < 2) _NbSegs = 2;
setInterpolationMode(Linear);
serialMaterial(f);
nlassert(_Owner);
resize(_Owner->getMaxSize());
initDateVect();
resetFromOwner();
}
if (ver >= 2)
{
CPSRibbonBase::serial(f);
CPSColoredParticle::serialColorScheme(f);
CPSMaterial::serialMaterial(f);
bool colorFading = _ColorFading;
f.serial(colorFading);
_ColorFading = colorFading;
if (ver >= 3)
{
uint32 tailNbSegs = _NbSegs;
f.serial(tailNbSegs);
}
if (f.isReading())
{
setTailNbSeg(_NbSegs);
touch();
}
}
}
//=======================================================
void CPSTailDot::step(TPSProcessPass pass)
{
NL_PS_FUNC(CPSTailDot_step)
if (pass == PSMotion)
{
if (!_Parametric)
{
updateGlobals();
}
}
else
if (
(pass == PSBlendRender && hasTransparentFaces())
|| (pass == PSSolidRender && hasOpaqueFaces())
)
{
uint32 step;
uint numToProcess;
computeSrcStep(step, numToProcess);
if (!numToProcess) return;
/// update the material color
CParticleSystem &ps = *(_Owner->getOwner());
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
_Mat.setColor(ps.getGlobalColorLighted());
}
else
{
_Mat.setColor(ps.getGlobalColor());
}
/** We support Auto-LOD for ribbons, although there is a built-in LOD (that change the geometry rather than the number of ribbons)
* that gives better result (both can be used simultaneously)
*/
displayRibbons(numToProcess, step);
}
else
if (pass == PSToolRender) // edition mode only
{
//showTool();
}
}
//=======================================================
void CPSTailDot::newElement(const CPSEmitterInfo &info)
{
NL_PS_FUNC(CPSTailDot_newElement)
CPSRibbonBase::newElement(info);
newColorElement(info);
}
//=======================================================
void CPSTailDot::deleteElement(uint32 index)
{
NL_PS_FUNC(CPSTailDot_deleteElement)
CPSRibbonBase::deleteElement(index);
deleteColorElement(index);
}
//=======================================================
void CPSTailDot::resize(uint32 size)
{
NL_PS_FUNC(CPSTailDot_resize)
nlassert(size < (1 << 16));
CPSRibbonBase::resize(size);
resizeColor(size);
}
//=======================================================
void CPSTailDot::updateMatAndVbForColor(void)
{
NL_PS_FUNC(CPSTailDot_updateMatAndVbForColor)
touch();
}
//==========================================================================
void CPSTailDot::displayRibbons(uint32 nbRibbons, uint32 srcStep)
{
// if (!FilterPS[8]) return;
NL_PS_FUNC(CPSTailDot_displayRibbons)
if (!nbRibbons) return;
nlassert(_Owner);
CPSRibbonBase::updateLOD();
if (_UsedNbSegs < 2) return;
const float date = _Owner->getOwner()->getSystemDate();
uint8 *currVert;
CVBnPB &VBnPB = getVBnPB(); // get the appropriate vb (built it if needed)
CVertexBuffer &VB = VBnPB.VB;
CIndexBuffer &PB = VBnPB.PB;
const uint32 vertexSize = VB.getVertexSize();
uint colorOffset=0;
IDriver *drv = this->getDriver();
#ifdef NL_DEBUG
nlassert(drv);
#endif
drv->setupModelMatrix(getLocalToWorldTrailMatrix());
_Owner->incrementNbDrawnParticles(nbRibbons); // for benchmark purpose
const uint numRibbonBatch = getNumRibbonsInVB(); // number of ribons to process at once
if (_UsedNbSegs == 0) return;
////////////////////
// Material setup //
////////////////////
CParticleSystem &ps = *(_Owner->getOwner());
bool useGlobalColor = ps.getColorAttenuationScheme() != NULL || ps.isUserColorUsed();
if (useGlobalColor != _GlobalColor)
{
_GlobalColor = useGlobalColor;
touch();
}
if (usesGlobalColorLighting() != _Lighted)
{
_Lighted = usesGlobalColorLighting();
touch();
}
if (ps.getForceGlobalColorLightingFlag() != _ForceLighted)
{
_ForceLighted = ps.getForceGlobalColorLightingFlag();
touch();
}
updateMaterial();
setupGlobalColor();
//
if (_ColorScheme)
{
colorOffset = VB.getColorOff();
}
/////////////////////
// Compute ribbons //
/////////////////////
uint toProcess;
uint ribbonIndex = 0; // index of the first ribbon in the batch being processed
uint32 fpRibbonIndex = 0; // fixed point index in source
if (_ColorScheme)
{
_ColorScheme->setColorType(drv->getVertexColorFormat());
}
do
{
toProcess = std::min((uint) (nbRibbons - ribbonIndex) /* = left to do */, numRibbonBatch);
VB.setNumVertices((_UsedNbSegs + 1) * toProcess);
{
CVertexBufferReadWrite vba;
VB.lock (vba);
currVert = (uint8 *) vba.getVertexCoordPointer();
/// compute colors
if (_ColorScheme)
{
_ColorScheme->makeN(this->_Owner, ribbonIndex, currVert + colorOffset, vertexSize, toProcess, _UsedNbSegs + 1, srcStep);
}
uint k = toProcess;
//////////////////////////////////////////////////////////////////////////////////////
// interpolate and project points the result is directly setup in the vertex buffer //
//////////////////////////////////////////////////////////////////////////////////////
if (!_Parametric)
{
//////////////////////
// INCREMENTAL CASE //
//////////////////////
do
{
// the parent class has a method to get the ribbons positions
computeRibbon((uint) (fpRibbonIndex >> 16), (CVector *) currVert, vertexSize);
currVert += vertexSize * (_UsedNbSegs + 1);
fpRibbonIndex += srcStep;
}
while (--k);
}
else
{
//////////////////////
// PARAMETRIC CASE //
//////////////////////
do
{
// we compute each pos thanks to the parametric curve
_Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), _UsedSegDuration, _UsedNbSegs + 1, (uint) (fpRibbonIndex >> 16),
(NLMISC::CVector *) currVert, vertexSize);
currVert += vertexSize * (_UsedNbSegs + 1);
fpRibbonIndex += srcStep;
}
while (--k);
}
}
const uint numLine = _UsedNbSegs * toProcess;
PB.setNumIndexes(2 * numLine);
// display the result
drv->activeIndexBuffer(PB);
drv->activeVertexBuffer(VB);
drv->renderLines (_Mat, 0, numLine);
ribbonIndex += toProcess;
}
while (ribbonIndex != nbRibbons);
}
//==========================================================================
bool CPSTailDot::hasTransparentFaces(void)
{
NL_PS_FUNC(CPSTailDot_hasTransparentFaces)
return getBlendingMode() != CPSMaterial::alphaTest ;
}
//==========================================================================
bool CPSTailDot::hasOpaqueFaces(void)
{
NL_PS_FUNC(CPSTailDot_hasOpaqueFaces)
return !hasTransparentFaces();
}
//==========================================================================
uint32 CPSTailDot::getNumWantedTris() const
{
NL_PS_FUNC(CPSTailDot_getNumWantedTris)
nlassert(_Owner);
//return _Owner->getMaxSize() * _NbSegs;
return _Owner->getSize() * _NbSegs;
}
//==========================================================================
CPSTailDot::CVBnPB &CPSTailDot::getVBnPB()
{
NL_PS_FUNC(CPSTailDot_getVBnPB)
/// choose the right vb
TVBMap &map = _ColorScheme ? (_ColorFading ? _FadedColoredVBMap : _ColoredVBMap) // per ribbon color
: (_ColorFading ? _FadedVBMap : _VBMap); // global color
TVBMap::iterator it = map.find(_UsedNbSegs + 1);
if (it != map.end())
{
return it->second;
}
else // must create this vb, with few different size, it is still interseting, though they are only destroyed at exit
{
const uint numRibbonInVB = getNumRibbonsInVB();
CVBnPB &VBnPB = map[_UsedNbSegs + 1]; // make an entry
/// set the vb format & size
/// In the case of a ribbon with color and fading, we encode the fading in a texture
/// If the ribbon has fading, but only a global color, we encode it in the primary color
CVertexBuffer &vb = VBnPB.VB;
vb.setPreferredMemory(CVertexBuffer::AGPVolatile, true);
vb.setVertexFormat(CVertexBuffer::PositionFlag
|(_ColorScheme || _ColorFading ? CVertexBuffer::PrimaryColorFlag : 0)
| (_ColorScheme && _ColorFading ? CVertexBuffer::TexCoord0Flag : 0));
vb.setNumVertices((_UsedNbSegs + 1) * numRibbonInVB ); // 1 seg = 1 line + terminal vertices
// set the primitive block size
CIndexBuffer &pb = VBnPB.PB;
pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
pb.setNumIndexes(2 * _UsedNbSegs * numRibbonInVB);
/// Setup the pb and vb parts. Not very fast but executed only once
uint vbIndex = 0;
uint pbIndex = 0;
CIndexBufferReadWrite ibaWrite;
pb.lock (ibaWrite);
CVertexBufferReadWrite vba;
vb.lock (vba);
for (uint i = 0; i < numRibbonInVB; ++i)
{
for (uint k = 0; k < (_UsedNbSegs + 1); ++k)
{
if (_ColorScheme && _ColorFading)
{
vba.setTexCoord(vbIndex, 0, 0.5f - 0.5f * ((float) k / _UsedNbSegs), 0);
}
else if (_ColorFading)
{
uint8 intensity = (uint8) (255 * (1.f - ((float) k / _UsedNbSegs)));
NLMISC::CRGBA col(intensity, intensity, intensity, intensity);
vba.setColor(vbIndex, col);
}
/// add 1 line in the primitive block
if (k != _UsedNbSegs)
{
ibaWrite.setLine(pbIndex, vbIndex, vbIndex + 1);
pbIndex+=2;
}
++vbIndex;
}
}
vb.setName("CPSTailDot");
NL_SET_IB_NAME(pb, "CPSTailDot");
return VBnPB;
}
}
//==========================================================================
uint CPSTailDot::getNumRibbonsInVB() const
{
NL_PS_FUNC(CPSTailDot_getNumRibbonsInVB)
/// approximation of the max number of vertices we want in a vb
const uint vertexInVB = 256;
return std::max(1u, (uint) (vertexInVB / (_UsedNbSegs + 1)));
}
//==========================================================================
void CPSTailDot::updateMaterial()
{
NL_PS_FUNC(CPSTailDot_updateMaterial)
if (!_Touch) return;
static NLMISC::CRefPtr<ITexture> ptGradTexture;
CParticleSystem &ps = *(_Owner->getOwner());
if (_ColorScheme)
{ // PER RIBBON COLOR
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting() || ps.getColorAttenuationScheme() || ps.isUserColorUsed())
{
if (_ColorFading) // global color + fading + per ribbon color
{
// the first stage is used to get fading * global color
// the second stage multiply the result by the diffuse colot
if (ptGradTexture == NULL) // have we got a gradient texture ?
{
ptGradTexture = CreateGradientTexture();
}
_Mat.setTexture(0, ptGradTexture);
CPSMaterial::forceTexturedMaterialStages(2); // use constant color 0 * diffuse, 1 stage needed
SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Constant);
SetupModulatedStage(_Mat, 1, CMaterial::Previous, CMaterial::Diffuse);
}
else // per ribbon color with global color
{
CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed
SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant);
}
}
else
{
if (_ColorFading) // per ribbon color, fading
{
if (ptGradTexture == NULL) // have we got a gradient texture ?
{
ptGradTexture = CreateGradientTexture();
}
_Mat.setTexture(0, ptGradTexture);
CPSMaterial::forceTexturedMaterialStages(1);
SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse);
}
else // per color ribbon with no fading, and no global color
{
CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only
}
}
}
else // GLOBAL COLOR
{
if (_ColorFading)
{
CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed
SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant);
}
else // constant color
{
CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only
}
}
_Touch = false;
}
//==========================================================================
void CPSTailDot::setupGlobalColor()
{
NL_PS_FUNC(CPSTailDot_setupGlobalColor)
/// setup the global color if it is used
CParticleSystem &ps = *(_Owner->getOwner());
if (_ColorScheme)
{
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
_Mat.texConstantColor(0, ps.getGlobalColorLighted());
}
else
{
_Mat.texConstantColor(0, ps.getGlobalColor());
}
}
else // GLOBAL COLOR with / without fading
{
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
NLMISC::CRGBA col;
col.modulateFromColor(ps.getGlobalColorLighted(), _Color);
if (_ColorFading)
{
_Mat.texConstantColor(0, col);
}
else // color attenuation, no fading :
{
_Mat.setColor(col);
}
}
else
if (ps.getColorAttenuationScheme() || ps.isUserColorUsed())
{
NLMISC::CRGBA col;
col.modulateFromColor(ps.getGlobalColor(), _Color);
if (_ColorFading)
{
_Mat.texConstantColor(0, col);
}
else // color attenuation, no fading :
{
_Mat.setColor(col);
}
}
else
{
if (_ColorFading)
{
_Mat.texConstantColor(0, _Color);
}
else // constant color
{
_Mat.setColor(_Color);
}
}
}
}
} // NL3D