Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   ps_ribbon_look_at.cpp Go to the documentation of this file. /* Copyright, 2001 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL 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 * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #include "std3d.h" #include "3d/ps_ribbon_look_at.h" #include "3d/particle_system.h" #include "3d/ps_macro.h" #include "3d/driver.h" namespace NL3D { // CPSRibbonLookAt implementation // const float ZEpsilon = 10E-3f; const float NormEpsilon = 10E-8f; struct CVectInfo { NLMISC::CVector Interp; NLMISC::CVector Proj; }; typedef std::vector<CVectInfo> TRibbonVect; // a vector used for intermediate computations CPSRibbonLookAt::TVBMap CPSRibbonLookAt::_VBMap; // index buffers with no color CPSRibbonLookAt::TVBMap CPSRibbonLookAt::_ColoredVBMap; // index buffer + colors //======================================================= CPSRibbonLookAt::CPSRibbonLookAt() { } //======================================================= CPSRibbonLookAt::~CPSRibbonLookAt() { // delete _DyingRibbons; } //======================================================= void CPSRibbonLookAt::serial(NLMISC::IStream &f) throw(NLMISC::EStream) { sint ver = f.serialVersion(4); if (ver > 3) { CPSRibbonBase::serial(f); } else { CPSParticle::serial(f); } CPSColoredParticle::serialColorScheme(f); CPSSizedParticle::serialSizeScheme(f); serialMaterial(f); uint32 dummy = 0; /* _NbDyingRibbons */ if (ver <= 3) { f.serial(_SegDuration, _NbSegs, dummy /*_NbDyingRibbons*/); } ITexture *tex = NULL; if (ver > 2) { f.serial(_Parametric); } if (!f.isReading()) { tex = _Tex; f.serialPolyPtr(tex); } else { f.serialPolyPtr(tex); setTexture(tex); setTailNbSeg(_NbSegs); // force to build the vb } } //======================================================= void CPSRibbonLookAt::setTexture(CSmartPtr<ITexture> tex) { _Tex = tex; updateMatAndVbForColor(); } //======================================================= void CPSRibbonLookAt::step(TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEt) { if (pass == PSMotion) { if (!_Parametric) { updateGlobals(); } } else if ( (pass == PSBlendRender && hasTransparentFaces()) || (pass == PSSolidRender && hasOpaqueFaces()) ) { uint32 step; uint numToProcess; computeSrcStep(step, numToProcess); if (!numToProcess) return; CParticleSystem &ps = *(_Owner->getOwner()); _Mat.setColor(ps.getGlobalColor()); displayRibbons(numToProcess, step); } else if (pass == PSToolRender) // edition mode only { //showTool(); } } //======================================================= void CPSRibbonLookAt::newElement(CPSLocated *emitterLocated, uint32 emitterIndex) { CPSRibbonBase::newElement(emitterLocated, emitterIndex); newColorElement(emitterLocated, emitterIndex); newSizeElement(emitterLocated, emitterIndex); } //======================================================= void CPSRibbonLookAt::deleteElement(uint32 index) { CPSRibbonBase::deleteElement(index); deleteColorElement(index); deleteSizeElement(index); } //======================================================= void CPSRibbonLookAt::resize(uint32 size) { nlassert(size < (1 << 16)); CPSRibbonBase::resize(size); resizeColor(size); resizeSize(size); } //======================================================= void CPSRibbonLookAt::updateMatAndVbForColor(void) { _Mat.setTexture(0, _Tex); } //======================================================= static inline void MakeProj(NLMISC::CVector &dest, const NLMISC::CVector &src) { if (fabsf(src.y) > NormEpsilon * NormEpsilon) { dest.x = src.x / src.y; dest.z = src.z / src.y; dest.y = src.y; } } static inline void BuildSlice(const NLMISC::CMatrix &mat, CVertexBuffer &vb, uint8 *currVert, uint32 vertexSize, const NLMISC::CVector &I, const NLMISC::CVector &K, TRibbonVect::iterator pos, TRibbonVect::iterator prev, TRibbonVect::iterator next, float ribSize) { CHECK_VERTEX_BUFFER(vb, currVert); CHECK_VERTEX_BUFFER(vb, currVert); NLMISC::CVector tangent; float invTgNorm; // inverse of the' norm of the projected segment float tgNorm; if (prev->Proj.y > ZEpsilon && next->Proj.y > ZEpsilon) // the 2 points are in front of the camera { tangent = next->Proj - prev->Proj; tangent.y = 0; tgNorm = tangent.norm(); if (fabs(tgNorm) > 10E-8) { invTgNorm = 1.f / tgNorm; } else { invTgNorm = 1.f; } // build orthogonals vectors to tangent *(NLMISC::CVector *) currVert = pos->Interp + ribSize * invTgNorm * (tangent.x * K - tangent.z * I); *(NLMISC::CVector *) (currVert + vertexSize) = pos->Interp + ribSize * invTgNorm * (- tangent.x * K + tangent.z * I); } else if (prev->Proj.y > ZEpsilon) // second point cross the near plane { // compute intersection point NLMISC::CVector inter; NLMISC::CVector tInter; if (fabsf(prev->Proj.y - next->Proj.y) > NormEpsilon) { float lambda = (next->Proj.y - ZEpsilon) / (next->Proj.y - prev->Proj.y); inter = lambda * prev->Interp + (1.f - lambda) * next->Interp; MakeProj(tInter, mat * inter); } else // { *(NLMISC::CVector *) currVert = pos->Interp; *(NLMISC::CVector *) (currVert + vertexSize) = pos->Interp; return; } tangent = tInter - prev->Proj; tangent.y = 0; tgNorm = tangent.norm(); if (fabs(tgNorm > 10E-8)) { invTgNorm = 1.f / tgNorm; } else { invTgNorm = 1.f; } // build orthogonals vectors to tangent *(NLMISC::CVector *) currVert = inter + ribSize * invTgNorm * (tangent.x * K - tangent.z * I); *(NLMISC::CVector *) (currVert + vertexSize) = inter + ribSize * invTgNorm * (- tangent.x * K + tangent.z * I); } else if (next->Proj.y > ZEpsilon) // first point cross the near plane { // compute intersection point // compute intersection point NLMISC::CVector inter; NLMISC::CVector tInter; if (fabsf(prev->Proj.y - next->Proj.y) > NormEpsilon) { float lambda = (next->Proj.y - ZEpsilon) / (next->Proj.y - prev->Proj.y); inter = lambda * prev->Interp + (1.f - lambda) * next->Interp; MakeProj(tInter, mat * inter); } else // { *(NLMISC::CVector *) currVert = pos->Interp; *(NLMISC::CVector *) (currVert + vertexSize) = pos->Interp; return; } tangent = next->Proj - tInter; tangent.y = 0; tgNorm = tangent.norm(); if (fabs(tgNorm > 10E-8)) { invTgNorm = 1.f / tgNorm; } else { invTgNorm = 1.f; } // build orthogonals vectors to tangent *(NLMISC::CVector *) currVert = inter + ribSize * invTgNorm * (tangent.x * K - tangent.z * I); *(NLMISC::CVector *) (currVert + vertexSize) = inter + ribSize * invTgNorm * (- tangent.x * K + tangent.z * I); } else // two points are not visible { *(NLMISC::CVector *) currVert = pos->Interp; *(NLMISC::CVector *) (currVert + vertexSize) = pos->Interp; } } //========================================================================== void CPSRibbonLookAt::displayRibbons(uint32 nbRibbons, uint32 srcStep) { 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 (build it if needed) CVertexBuffer &VB = VBnPB.VB; CPrimitiveBlock &PB = VBnPB.PB; const uint32 vertexSize = VB.getVertexSize(); uint colorOffset=0; const uint32 vertexSizeX2 = vertexSize << 1; const NLMISC::CVector I = _Owner->computeI(); const NLMISC::CVector K = _Owner->computeK(); CMatrix mat = _Owner->isInSystemBasis() ? getViewMat() * getSysMat() : getViewMat(); IDriver *drv = this->getDriver(); setupDriverModelMatrix(); drv->activeVertexBuffer(VB); _Owner->incrementNbDrawnParticles(nbRibbons); // for benchmark purpose const uint numRibbonBatch = getNumRibbonsInVB(); // number of ribons to process at once static TRibbonVect currRibbon; static std::vector<float> sizes; static std::vector<NLMISC::CRGBA> colors; if (_UsedNbSegs == 0) return; currRibbon.resize(_UsedNbSegs + 1); sizes.resize(numRibbonBatch); CParticleSystem &ps = *(_Owner->getOwner()); if (ps.getColorAttenuationScheme() != NULL) { CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColor()); } else { forceModulateConstantColor(false); _Mat.setColor(ps.getGlobalColor()); } if (_ColorScheme) { colorOffset = VB.getColorOff(); colors.resize(numRibbonBatch); } uint toProcess; uint ribbonIndex = 0; // index of the first ribbon in the batch being processed uint32 fpRibbonIndex = 0; do { toProcess = std::min((uint) (nbRibbons - ribbonIndex) /* = left to do */, numRibbonBatch); const float *ptCurrSize; uint32 ptCurrSizeIncrement; if (_SizeScheme) { ptCurrSize = (float *) _SizeScheme->make(this->_Owner, ribbonIndex, &sizes[0], sizeof(float), toProcess, true, srcStep); ptCurrSizeIncrement = 1; } else { ptCurrSize = &_ParticleSize; ptCurrSizeIncrement = 0; } NLMISC::CRGBA *ptCurrColor=0; if (_ColorScheme) { colors.resize(nbRibbons); ptCurrColor = (NLMISC::CRGBA *) _ColorScheme->make(this->_Owner, ribbonIndex, &colors[0], sizeof(NLMISC::CRGBA), toProcess, true, srcStep); } currVert = (uint8 *) VB.getVertexCoordPointer(); for (uint k = ribbonIndex; k < ribbonIndex + toProcess; ++k) { TRibbonVect::iterator rIt = currRibbon.begin(), rItEnd = currRibbon.end(), rItEndMinusOne = rItEnd - 1; // interpolate and project points // if (!_Parametric) { // INCREMENTAL CASE // // the parent class has a method to get the ribbons positions computeRibbon((uint) (fpRibbonIndex >> 16), &rIt->Interp, sizeof(CVectInfo)); do { MakeProj(rIt->Proj, mat * rIt->Interp); ++rIt; } while (rIt != rItEnd); } else { // PARAMETRIC CASE // // we compute each pos thanks to the parametric curve _Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), _UsedSegDuration, _UsedNbSegs + 1, (uint) (fpRibbonIndex >> 16), &rIt->Interp, sizeof(CVectInfo) ); // project each position now do { MakeProj(rIt->Proj, mat * rIt->Interp); ++rIt; } while (rIt != rItEnd); } rIt = currRibbon.begin(); // setup colors if (_ColorScheme) { uint8 *currColVertex = currVert + colorOffset; uint colCount = (_UsedNbSegs + 1) << 1; do { * (CRGBA *) currColVertex = *ptCurrColor; currColVertex += vertexSize; } while (--colCount); ++ptCurrColor; } // deals with first point BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt, rIt, rIt + 1, *ptCurrSize); currVert += vertexSizeX2; ++rIt; // deals with other points for (;;) // we assume at least 2 segments, so we must have a middle point { // build 2 vertices with the right tangent. /* to project 2 */ is old projected point BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt, rIt - 1, rIt + 1, *ptCurrSize); // next position ++rIt; if (rIt == rItEndMinusOne) break; // next vertex currVert += vertexSizeX2; } currVert += vertexSizeX2; // last point. BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt , rIt - 1, rIt, *ptCurrSize); ptCurrSize += ptCurrSizeIncrement; currVert += vertexSizeX2; fpRibbonIndex += srcStep; } PB.setNumTri((_UsedNbSegs << 1) * toProcess); // display the result drv->render(PB, _Mat); ribbonIndex += toProcess; } while (ribbonIndex != nbRibbons); } //========================================================================== bool CPSRibbonLookAt::hasTransparentFaces(void) { return getBlendingMode() != CPSMaterial::alphaTest ; } //========================================================================== bool CPSRibbonLookAt::hasOpaqueFaces(void) { return !hasTransparentFaces(); } //========================================================================== uint32 CPSRibbonLookAt::getMaxNumFaces(void) const { nlassert(_Owner); return _Owner->getMaxSize() * _NbSegs * 2; } //========================================================================== CPSRibbonLookAt::CVBnPB &CPSRibbonLookAt::getVBnPB() { TVBMap &map = _ColorScheme ? _VBMap : _ColoredVBMap; TVBMap::iterator it = map.find(_UsedNbSegs + 1); if (it != map.end()) { return it->second; } else // must create this vb { const uint numRibbonInVB = getNumRibbonsInVB(); CVBnPB &VBnPB = map[_UsedNbSegs + 1]; // make an entry CVertexBuffer &vb = VBnPB.VB; vb.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag | (_ColorScheme ? CVertexBuffer::PrimaryColorFlag : 0)); vb.setNumVertices(2 * (_UsedNbSegs + 1) * numRibbonInVB ); // set the primitive block size CPrimitiveBlock &pb = VBnPB.PB; pb.setNumTri((_UsedNbSegs << 1) * numRibbonInVB); uint vbIndex = 0; uint pbIndex = 0; for (uint i = 0; i < numRibbonInVB; ++i) { for (uint k = 0; k < (_UsedNbSegs + 1); ++k) { vb.setTexCoord(vbIndex, 0, CUV((1.f - k / (float) _UsedNbSegs), 0)); vb.setTexCoord(vbIndex + 1, 0, CUV((1.f - k / (float) _UsedNbSegs), 1)); if (k != _UsedNbSegs) { pb.setTri(pbIndex ++, vbIndex + 1, vbIndex + 2, vbIndex); pb.setTri(pbIndex ++, vbIndex + 1, vbIndex + 3, vbIndex + 2); } vbIndex += 2; } } return VBnPB; } } //========================================================================== uint CPSRibbonLookAt::getNumRibbonsInVB() const { const uint vertexInVB = 256; return std::max(1u, (uint) (vertexInVB / (_UsedNbSegs + 1))); } } // NL3D