Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03193.html | 988 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 988 insertions(+) create mode 100644 docs/doxygen/nel/a03193.html (limited to 'docs/doxygen/nel/a03193.html') diff --git a/docs/doxygen/nel/a03193.html b/docs/doxygen/nel/a03193.html new file mode 100644 index 00000000..bba5dbed --- /dev/null +++ b/docs/doxygen/nel/a03193.html @@ -0,0 +1,988 @@ + + +NeL: NL3D::CPSFaceLookAtHelper class Reference + + + +

NL3D::CPSFaceLookAtHelper Class Reference

Detailed Description

+Well, we could have put a method template in CPSFaceLookAt, but some compilers want the definition of the methods in the header, and some compilers don't want friend with function template, so we use a static method template of a friend class instead, which gives us the same result :) +

+ +

+Definition at line 62 of file ps_face_look_at.cpp. + + + + + + + + +

Static Public Member Functions
template<class T> void computeOrientationVectors (T speedIt, const CVector &I, const CVector &K, CLookAtAlign *dest, uint size)
template<class T> void drawLookAt (T it, T speedIt, CPSFaceLookAt &la, uint size, uint32 srcStep)
template<class T> void drawLookAtAlignOnMotion (T it, T speedIt, CPSFaceLookAt &la, uint size, uint32 srcStep)
+

Member Function Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NL3D::CPSFaceLookAtHelper::computeOrientationVectors ( T speedIt,
const CVector & I,
const CVector & K,
CLookAtAlign * dest,
uint size
) [inline, static]
+
+ + + + + +
+ + + +
+compute orientation vectors depending on speed +
+Definition at line 68 of file ps_face_look_at.cpp. +
+References NL3D::CLookAtAlign::I, NL3D::CLookAtAlign::K, nlassert, NLMISC::CVector::normed(), size, and uint. +
+Referenced by drawLookAtAlignOnMotion(). +
+
00069 { +00070 nlassert(size > 0); +00071 const CLookAtAlign *endDest = dest + size; +00072 do +00073 { +00074 // tmp unoptimized slow version +00075 CVector normedSpeed = (*speedIt).normed(); +00076 float iProj = normedSpeed * I; +00077 float kProj = normedSpeed * K; +00078 dest->I = iProj * I + kProj * K; +00079 dest->K = (- kProj * I + iProj * K).normed(); +00080 ++ speedIt; +00081 ++ dest; +00082 } +00083 while(dest != endDest); +00084 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NL3D::CPSFaceLookAtHelper::drawLookAt ( T it,
T speedIt,
CPSFaceLookAt & la,
uint size,
uint32 srcStep
) [inline, static]
+
+ + + + + +
+ + + +
+render look at, but dont align on motion +
+Definition at line 379 of file ps_face_look_at.cpp. +
+References NL3D::CPSRotated2DParticle::_Angle2D, NL3D::CPSRotated2DParticle::_Angle2DScheme, NL3D::CPSFaceLookAt::_IndependantSizes, NL3D::CPSMaterial::_Mat, NL3D::CPSFaceLookAt::_MotionBlurCoeff, NL3D::CPSLocatedBindable::_Owner, NL3D::CPSSizedParticle::_ParticleSize, NL3D::CPSFaceLookAt::_SecondSize, NL3D::CPSSizedParticle::_SizeScheme, NL3D::CPSFaceLookAt::_Threshold, NL3D::IDriver::activeVertexBuffer(), CHECK_VERTEX_BUFFER, NL3D::CPSLocatedBindable::computeI(), NL3D::CPSLocatedBindable::computeJ(), NL3D::CPSLocatedBindable::computeK(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CPSLocated::getLocalToWorldMatrix(), NL3D::CPSQuad::getNeededVB(), NL3D::CPSSizedParticle::getSize(), NL3D::CPSSizedParticle::getSizeScheme(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CPSLocatedBindable::getViewMat(), NL3D::CPSLocated::incrementNbDrawnParticles(), NL3D::CPSAttribMaker< float >::make(), nlassert, NLMISC::CVector::norm(), NLMISC::OptFastFloor(), NLMISC::OptFastFloorBegin(), NLMISC::OptFastFloorEnd(), PARTICLES_CHECK_MEM, NL3D::IDriver::renderOrientedQuads(), NL3D::IDriver::renderQuads(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), sint32, size, stride, uint, uint32, uint8, NL3D::CPSQuad::updateMatBeforeRendering(), NL3D::CPSQuad::updateVbColNUVForRender(), NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +
+
00380 { +00381 //uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00382 PARTICLES_CHECK_MEM; +00383 nlassert(la._Owner); +00384 IDriver *driver = la.getDriver(); +00385 +00386 la.updateMatBeforeRendering(driver); +00387 +00388 CVertexBuffer &vb = la.getNeededVB(); +00389 la._Owner->incrementNbDrawnParticles(size); // for benchmark purpose +00390 la.setupDriverModelMatrix(); +00391 driver->activeVertexBuffer(vb); +00392 const CVector I = la.computeI(); +00393 const CVector J = la.computeJ(); +00394 const CVector K = la.computeK(); +00395 const float *rotTable = CPSRotated2DParticle::getRotTable(); +00396 // for each the particle can be constantly rotated or have an independant rotation for each particle +00397 // number of face left, and number of face to process at once +00398 uint32 leftToDo = size, toProcess; +00399 float pSizes[CPSQuad::quadBufSize]; // the sizes to use +00400 float pSecondSizes[CPSQuad::quadBufSize]; // the second sizes to use +00401 float *currentSize; +00402 uint32 currentSizeStep = la._SizeScheme ? 1 : 0; +00403 // point the vector part in the current vertex +00404 uint8 *ptPos; +00405 // strides to go from one vertex to another one +00406 const uint32 stride = vb.getVertexSize(), stride2 = stride << 1, stride3 = stride + stride2, stride4 = stride << 2; +00407 //PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick; +00408 if (!la._Angle2DScheme) +00409 { +00410 // constant rotation case +00411 do +00412 { +00413 // restart at the beginning of the vertex buffer +00414 ptPos = (uint8 *) vb.getVertexCoordPointer(); +00415 toProcess = leftToDo <= CPSQuad::quadBufSize ? leftToDo : CPSQuad::quadBufSize; +00416 +00417 if (la._SizeScheme) +00418 { +00419 currentSize = (float *) la._SizeScheme->make(la._Owner, size- leftToDo, pSizes, sizeof(float), toProcess, true, srcStep); +00420 } +00421 else +00422 { +00423 currentSize = &la._ParticleSize; +00424 } +00425 +00426 la.updateVbColNUVForRender(vb, size - leftToDo, toProcess, srcStep); +00427 T endIt = it + toProcess; +00428 if (la._MotionBlurCoeff == 0.f) +00429 { +00430 if (!la._IndependantSizes) +00431 { +00432 const uint32 tabIndex = (((uint32) la._Angle2D) & 0xff) << 2; +00433 const CVector v1 = rotTable[tabIndex] * I + rotTable[tabIndex + 1] * K; +00434 const CVector v2 = rotTable[tabIndex + 2] * I + rotTable[tabIndex + 3] * K; +00435 if (currentSizeStep) +00436 { +00437 while (it != endIt) +00438 { +00439 CHECK_VERTEX_BUFFER(vb, ptPos); +00440 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x; +00441 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y; +00442 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z; +00443 ptPos += stride; +00444 +00445 CHECK_VERTEX_BUFFER(vb, ptPos); +00446 ((CVector *) ptPos)->x = (*it).x + *currentSize * v2.x; +00447 ((CVector *) ptPos)->y = (*it).y + *currentSize * v2.y; +00448 ((CVector *) ptPos)->z = (*it).z + *currentSize * v2.z; +00449 ptPos += stride; +00450 +00451 CHECK_VERTEX_BUFFER(vb, ptPos); +00452 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x; +00453 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y; +00454 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z; +00455 ptPos += stride; +00456 +00457 CHECK_VERTEX_BUFFER(vb, ptPos); +00458 ((CVector *) ptPos)->x = (*it).x - *currentSize * v2.x; +00459 ((CVector *) ptPos)->y = (*it).y - *currentSize * v2.y; +00460 ((CVector *) ptPos)->z = (*it).z - *currentSize * v2.z; +00461 ptPos += stride; +00462 +00463 ++it; +00464 currentSize += currentSizeStep; +00465 } +00466 } +00467 else +00468 { +00469 // constant size +00470 const CVector myV1 = *currentSize * v1; +00471 const CVector myV2 = *currentSize * v2; +00472 +00473 while (it != endIt) +00474 { +00475 CHECK_VERTEX_BUFFER(vb, ptPos); +00476 ((CVector *) ptPos)->x = (*it).x + myV1.x; +00477 ((CVector *) ptPos)->y = (*it).y + myV1.y; +00478 ((CVector *) ptPos)->z = (*it).z + myV1.z; +00479 ptPos += stride; +00480 +00481 CHECK_VERTEX_BUFFER(vb, ptPos); +00482 ((CVector *) ptPos)->x = (*it).x + myV2.x; +00483 ((CVector *) ptPos)->y = (*it).y + myV2.y; +00484 ((CVector *) ptPos)->z = (*it).z + myV2.z; +00485 ptPos += stride; +00486 +00487 CHECK_VERTEX_BUFFER(vb, ptPos); +00488 ((CVector *) ptPos)->x = (*it).x - myV1.x; +00489 ((CVector *) ptPos)->y = (*it).y - myV1.y; +00490 ((CVector *) ptPos)->z = (*it).z - myV1.z; +00491 ptPos += stride; +00492 +00493 CHECK_VERTEX_BUFFER(vb, ptPos); +00494 ((CVector *) ptPos)->x = (*it).x - myV2.x; +00495 ((CVector *) ptPos)->y = (*it).y - myV2.y; +00496 ((CVector *) ptPos)->z = (*it).z - myV2.z; +00497 ptPos += stride; +00498 ++it; +00499 } +00500 } +00501 } +00502 else // independant sizes +00503 { +00504 const CVector v1 = CPSUtil::getCos((sint32) la._Angle2D) * I + CPSUtil::getSin((sint32) la._Angle2D) * K; +00505 const CVector v2 = - CPSUtil::getSin((sint32) la._Angle2D) * I + CPSUtil::getCos((sint32) la._Angle2D) * K; +00506 +00507 float *currentSize2; +00508 float secondSize; +00509 uint32 currentSizeStep2; +00510 if (la._SecondSize.getSizeScheme()) +00511 { +00512 currentSize2 = (float *) la._SecondSize.getSizeScheme()->make(la._Owner, size- leftToDo, pSecondSizes, sizeof(float), toProcess, true, srcStep); +00513 currentSizeStep2 = 1; +00514 } +00515 else +00516 { +00517 secondSize = la._SecondSize.getSize(); +00518 currentSize2 = &secondSize; +00519 currentSizeStep2 = 0; +00520 } +00521 +00522 +00523 while (it != endIt) +00524 { +00525 CHECK_VERTEX_BUFFER(vb, ptPos); +00526 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x + *currentSize2 * v2.x; +00527 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y + *currentSize2 * v2.y; +00528 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z + *currentSize2 * v2.z; +00529 ptPos += stride; +00530 +00531 CHECK_VERTEX_BUFFER(vb, ptPos); +00532 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x + *currentSize2 * v2.x; +00533 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y + *currentSize2 * v2.y; +00534 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z + *currentSize2 * v2.z; +00535 ptPos += stride; +00536 +00537 CHECK_VERTEX_BUFFER(vb, ptPos); +00538 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x - *currentSize2 * v2.x; +00539 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y - *currentSize2 * v2.y; +00540 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z - *currentSize2 * v2.z; +00541 ptPos += stride; +00542 +00543 CHECK_VERTEX_BUFFER(vb, ptPos); +00544 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x - *currentSize2 * v2.x; +00545 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y - *currentSize2 * v2.y; +00546 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z - *currentSize2 * v2.z; +00547 ptPos += stride; +00548 ++it; +00549 currentSize += currentSizeStep; +00550 currentSize2 += currentSizeStep2; +00551 } +00552 } +00553 //tmp +00554 //uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00555 driver->renderQuads(la._Mat, 0, toProcess); +00556 //PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick; +00557 } +00558 else +00559 { +00560 // perform motion, blur, we need an iterator on speed +00561 // independant sizes and rotation not supported for now with motion blur +00562 const CVector v1 = I + K; +00563 const CVector v2 = K - I; +00564 CVector startV, endV, mbv1, mbv1n, mbv12, mbv2; +00565 // norme of the v1 vect +00566 float n; +00567 const float epsilon = 10E-5f; +00568 const float normEpsilon = 10E-6f; +00569 +00570 CMatrix tMat = la.getViewMat() * la._Owner->getLocalToWorldMatrix(); +00571 +00572 while (it != endIt) +00573 { +00574 // project the speed in the projection plane +00575 // this give us the v1 vect +00576 startV = tMat * *it ; +00577 endV = tMat * (*it + *speedIt); +00578 if (startV.y > epsilon || endV.y > epsilon) +00579 { +00580 if (startV.y < epsilon) +00581 { +00582 if (fabsf(endV.y - startV.y) > normEpsilon) +00583 { +00584 startV = endV + (endV.y - epsilon) / (endV.y - startV.y) * (startV - endV); +00585 } +00586 startV.y = epsilon; +00587 } +00588 else if (endV.y < epsilon) +00589 { +00590 if (fabsf(endV.y - startV.y) > normEpsilon) +00591 { +00592 endV = startV + (startV.y - epsilon) / (startV.y - endV.y) * (endV - startV); +00593 } +00594 endV.y = epsilon; +00595 } +00596 +00597 mbv1 = (startV.x / startV.y - endV.x / endV.y) * I +00598 + (startV.z / startV.y - endV.z / endV.y) * K ; +00599 +00600 n = mbv1.norm(); +00601 if (n > la._Threshold) +00602 { +00603 mbv1 *= la._Threshold / n; +00604 n = la._Threshold; +00605 } +00606 if (n > normEpsilon) +00607 { +00608 mbv1n = mbv1 / n; +00609 mbv2 = *currentSize * (J ^ mbv1n); +00610 mbv12 = -*currentSize * mbv1n; +00611 mbv1 *= *currentSize * (1 + la._MotionBlurCoeff * n * n) / n; +00612 +00613 *(CVector *) ptPos = *it - mbv2; +00614 *(CVector *) (ptPos + stride) = *it + mbv1; +00615 *(CVector *) (ptPos + stride2) = *it + mbv2; +00616 *(CVector *) (ptPos + stride3) = *it + mbv12; +00617 +00618 +00619 CHECK_VERTEX_BUFFER(vb, ptPos); +00620 ((CVector *) ptPos)->x = (*it).x - mbv2.x; +00621 ((CVector *) ptPos)->y = (*it).y - mbv2.y; +00622 ((CVector *) ptPos)->z = (*it).z - mbv2.z; +00623 +00624 CHECK_VERTEX_BUFFER(vb, ptPos + stride); +00625 ((CVector *) (ptPos + stride))->x = (*it).x + mbv1.x; +00626 ((CVector *) (ptPos + stride))->y = (*it).y + mbv1.y; +00627 ((CVector *) (ptPos + stride))->z = (*it).z + mbv1.z; +00628 +00629 CHECK_VERTEX_BUFFER(vb, ptPos + stride2); +00630 ((CVector *) (ptPos + stride2))->x = (*it).x + mbv2.x; +00631 ((CVector *) (ptPos + stride2))->y = (*it).y + mbv2.y; +00632 ((CVector *) (ptPos + stride2))->z = (*it).z + mbv2.z; +00633 +00634 +00635 CHECK_VERTEX_BUFFER(vb, ptPos + stride3); +00636 ((CVector *) (ptPos + stride3))->x = (*it).x + mbv12.x; +00637 ((CVector *) (ptPos + stride3))->y = (*it).y + mbv12.y; +00638 ((CVector *) (ptPos + stride3))->z = (*it).z + mbv12.z; +00639 +00640 } +00641 else // speed too small, we must avoid imprecision +00642 { +00643 CHECK_VERTEX_BUFFER(vb, ptPos); +00644 ((CVector *) ptPos)->x = (*it).x - *currentSize * v2.x; +00645 ((CVector *) ptPos)->y = (*it).y - *currentSize * v2.y; +00646 ((CVector *) ptPos)->z = (*it).z - *currentSize * v2.z; +00647 +00648 CHECK_VERTEX_BUFFER(vb, ptPos + stride); +00649 ((CVector *) (ptPos + stride))->x = (*it).x + *currentSize * v1.x; +00650 ((CVector *) (ptPos + stride))->y = (*it).y + *currentSize * v1.y; +00651 ((CVector *) (ptPos + stride))->z = (*it).z + *currentSize * v1.z; +00652 +00653 CHECK_VERTEX_BUFFER(vb, ptPos + stride2); +00654 ((CVector *) (ptPos + stride2))->x = (*it).x + *currentSize * v2.x; +00655 ((CVector *) (ptPos + stride2))->y = (*it).y + *currentSize * v2.y; +00656 ((CVector *) (ptPos + stride2))->z = (*it).z + *currentSize * v2.z; +00657 +00658 +00659 CHECK_VERTEX_BUFFER(vb, ptPos + stride3); +00660 ((CVector *) (ptPos + stride3))->x = (*it).x - *currentSize * v1.x; +00661 ((CVector *) (ptPos + stride3))->y = (*it).y - *currentSize * v1.y; +00662 ((CVector *) (ptPos + stride3))->z = (*it).z - *currentSize * v1.z; +00663 } +00664 } +00665 else +00666 { +00667 +00668 CHECK_VERTEX_BUFFER(vb, ptPos); +00669 ((CVector *) ptPos)->x = (*it).x - *currentSize * v2.x; +00670 ((CVector *) ptPos)->y = (*it).y - *currentSize * v2.y; +00671 ((CVector *) ptPos)->z = (*it).z - *currentSize * v2.z; +00672 +00673 CHECK_VERTEX_BUFFER(vb, ptPos + stride); +00674 ((CVector *) (ptPos + stride))->x = (*it).x + *currentSize * v1.x; +00675 ((CVector *) (ptPos + stride))->y = (*it).y + *currentSize * v1.y; +00676 ((CVector *) (ptPos + stride))->z = (*it).z + *currentSize * v1.z; +00677 +00678 CHECK_VERTEX_BUFFER(vb, ptPos + stride2); +00679 ((CVector *) (ptPos + stride2))->x = (*it).x + *currentSize * v2.x; +00680 ((CVector *) (ptPos + stride2))->y = (*it).y + *currentSize * v2.y; +00681 ((CVector *) (ptPos + stride2))->z = (*it).z + *currentSize * v2.z; +00682 +00683 +00684 CHECK_VERTEX_BUFFER(vb, ptPos + stride3); +00685 ((CVector *) (ptPos + stride3))->x = (*it).x - *currentSize * v1.x; +00686 ((CVector *) (ptPos + stride3))->y = (*it).y - *currentSize * v1.y; +00687 ((CVector *) (ptPos + stride3))->z = (*it).z - *currentSize * v1.z; +00688 } +00689 +00690 ptPos += stride4; +00691 ++it; +00692 ++speedIt; +00693 currentSize += currentSizeStep; +00694 } +00695 //uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00696 driver->renderOrientedQuads(la._Mat, 0, toProcess); +00697 //PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick; +00698 } +00699 leftToDo -= toProcess; +00700 } +00701 while (leftToDo); +00702 } +00703 else +00704 { +00705 float pAngles[CPSQuad::quadBufSize]; // the angles to use +00706 float *currentAngle; +00707 do +00708 { +00709 // restart at the beginning of the vertex buffer +00710 ptPos = (uint8 *) vb.getVertexCoordPointer(); +00711 toProcess = leftToDo <= CPSQuad::quadBufSize ? leftToDo : CPSQuad::quadBufSize; +00712 if (la._SizeScheme) +00713 { +00714 currentSize = (float *) la._SizeScheme->make(la._Owner, size - leftToDo, pSizes, sizeof(float), toProcess, true, srcStep); +00715 } +00716 else +00717 { +00718 currentSize = &la._ParticleSize; +00719 } +00720 currentAngle = (float *) la._Angle2DScheme->make(la._Owner, size - leftToDo, pAngles, sizeof(float), toProcess, true, srcStep); +00721 la.updateVbColNUVForRender(vb, size - leftToDo, toProcess, srcStep); +00722 T endIt = it + toProcess; +00723 CVector v1, v2; +00724 NLMISC::OptFastFloorBegin(); +00725 if (!la._IndependantSizes) +00726 { +00727 while (it != endIt) +00728 { +00729 const uint32 tabIndex = ((NLMISC::OptFastFloor(*currentAngle)) & 0xff) << 2; +00730 // lets avoid some ctor calls +00731 v1.x = *currentSize * (rotTable[tabIndex] * I.x + rotTable[tabIndex + 1] * K.x); +00732 v1.y = *currentSize * (rotTable[tabIndex] * I.y + rotTable[tabIndex + 1] * K.y); +00733 v1.z = *currentSize * (rotTable[tabIndex] * I.z + rotTable[tabIndex + 1] * K.z); +00734 +00735 v2.x = *currentSize * (rotTable[tabIndex + 2] * I.x + rotTable[tabIndex + 3] * K.x); +00736 v2.y = *currentSize * (rotTable[tabIndex + 2] * I.y + rotTable[tabIndex + 3] * K.y); +00737 v2.z = *currentSize * (rotTable[tabIndex + 2] * I.z + rotTable[tabIndex + 3] * K.z); +00738 +00739 CHECK_VERTEX_BUFFER(vb, ptPos); +00740 CHECK_VERTEX_BUFFER(vb, ptPos + stride); +00741 CHECK_VERTEX_BUFFER(vb, ptPos + stride2); +00742 CHECK_VERTEX_BUFFER(vb, ptPos + stride3); +00743 +00744 ((CVector *) ptPos)->x = (*it).x + v1.x; +00745 ((CVector *) ptPos)->y = (*it).y + v1.y; +00746 ((CVector *) ptPos)->z = (*it).z + v1.z; +00747 ptPos += stride; +00748 +00749 ((CVector *) ptPos)->x = (*it).x + v2.x; +00750 ((CVector *) ptPos)->y = (*it).y + v2.y; +00751 ((CVector *) ptPos)->z = (*it).z + v2.z; +00752 ptPos += stride; +00753 +00754 ((CVector *) ptPos)->x = (*it).x - v1.x; +00755 ((CVector *) ptPos)->y = (*it).y - v1.y; +00756 ((CVector *) ptPos)->z = (*it).z - v1.z; +00757 ptPos += stride; +00758 +00759 ((CVector *) ptPos)->x = (*it).x - v2.x; +00760 ((CVector *) ptPos)->y = (*it).y - v2.y; +00761 ((CVector *) ptPos)->z = (*it).z - v2.z; +00762 ptPos += stride; +00763 +00764 ++it; +00765 currentSize += currentSizeStep; +00766 ++currentAngle; +00767 } +00768 } +00769 else // independant size, and non-constant rotation +00770 { +00771 +00772 float *currentSize2; +00773 float secondSize; +00774 uint32 currentSizeStep2; +00775 if (la._SecondSize.getSizeScheme()) +00776 { +00777 currentSize2 = (float *) la._SecondSize.getSizeScheme()->make(la._Owner, size- leftToDo, pSecondSizes, sizeof(float), toProcess, true, srcStep); +00778 currentSizeStep2 = 1; +00779 } +00780 else +00781 { +00782 secondSize = la._SecondSize.getSize(); +00783 currentSize2 = &secondSize; +00784 currentSizeStep2 = 0; +00785 } +00786 +00787 float cosAngle, sinAngle; +00788 while (it != endIt) +00789 { +00790 cosAngle = CPSUtil::getCos((sint32) *currentAngle); +00791 sinAngle = CPSUtil::getSin((sint32) *currentAngle); +00792 v1 = cosAngle * I + sinAngle * K; +00793 v2 = - sinAngle * I + cosAngle * K; +00794 +00795 CHECK_VERTEX_BUFFER(vb, ptPos); +00796 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x + *currentSize2 * v2.x; +00797 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y + *currentSize2 * v2.y; +00798 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z + *currentSize2 * v2.z; +00799 ptPos += stride; +00800 +00801 CHECK_VERTEX_BUFFER(vb, ptPos); +00802 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x + *currentSize2 * v2.x; +00803 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y + *currentSize2 * v2.y; +00804 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z + *currentSize2 * v2.z; +00805 ptPos += stride; +00806 +00807 CHECK_VERTEX_BUFFER(vb, ptPos); +00808 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x - *currentSize2 * v2.x; +00809 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y - *currentSize2 * v2.y; +00810 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z - *currentSize2 * v2.z; +00811 ptPos += stride; +00812 +00813 CHECK_VERTEX_BUFFER(vb, ptPos); +00814 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x - *currentSize2 * v2.x; +00815 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y - *currentSize2 * v2.y; +00816 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z - *currentSize2 * v2.z; +00817 ptPos += stride; +00818 ++it; +00819 ++currentAngle; +00820 currentSize += currentSizeStep; +00821 currentSize2 += currentSizeStep2; +00822 } +00823 } +00824 NLMISC::OptFastFloorEnd(); +00825 //tmp +00826 // uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00827 driver->renderQuads(la._Mat, 0, toProcess); +00828 //PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick;*/ +00829 leftToDo -= toProcess; +00830 } +00831 while (leftToDo); +00832 } +00833 PARTICLES_CHECK_MEM; +00834 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion ( T it,
T speedIt,
CPSFaceLookAt & la,
uint size,
uint32 srcStep
) [inline, static]
+
+ + + + + +
+ + + +
+Draw look at and align them on motion +
+Definition at line 89 of file ps_face_look_at.cpp. +
+References NL3D::CPSRotated2DParticle::_Angle2D, NL3D::CPSRotated2DParticle::_Angle2DScheme, NL3D::CPSFaceLookAt::_IndependantSizes, NL3D::CPSMaterial::_Mat, NL3D::CPSLocatedBindable::_Owner, NL3D::CPSSizedParticle::_ParticleSize, NL3D::CPSFaceLookAt::_SecondSize, NL3D::CPSSizedParticle::_SizeScheme, NL3D::IDriver::activeVertexBuffer(), CHECK_VERTEX_BUFFER, NL3D::CPSLocatedBindable::computeI(), NL3D::CPSLocatedBindable::computeK(), computeOrientationVectors(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CPSQuad::getNeededVB(), NL3D::CPSSizedParticle::getSize(), NL3D::CPSSizedParticle::getSizeScheme(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CLookAtAlign::I, NL3D::CPSLocated::incrementNbDrawnParticles(), NL3D::CLookAtAlign::K, NL3D::CPSAttribMaker< float >::make(), nlassert, NLMISC::OptFastFloor(), NLMISC::OptFastFloorBegin(), NLMISC::OptFastFloorEnd(), PARTICLES_CHECK_MEM, NL3D::IDriver::renderQuads(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), sint32, size, stride, uint, uint32, uint8, NL3D::CPSQuad::updateMatBeforeRendering(), NL3D::CPSQuad::updateVbColNUVForRender(), NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +
+
00090 { +00091 PARTICLES_CHECK_MEM; +00092 nlassert(la._Owner); +00093 IDriver *driver = la.getDriver(); +00094 +00095 la.updateMatBeforeRendering(driver); +00096 +00097 CVertexBuffer &vb = la.getNeededVB(); +00098 la._Owner->incrementNbDrawnParticles(size); // for benchmark purpose +00099 la.setupDriverModelMatrix(); +00100 driver->activeVertexBuffer(vb); +00101 const CVector I = la.computeI(); +00102 const CVector K = la.computeK(); +00103 const float *rotTable = CPSRotated2DParticle::getRotTable(); +00104 // for each the particle can be constantly rotated or have an independant rotation for each particle +00105 // number of face left, and number of face to process at once +00106 uint32 leftToDo = size, toProcess; +00107 float pSizes[CPSQuad::quadBufSize]; // the sizes to use +00108 float pSecondSizes[CPSQuad::quadBufSize]; // the second sizes to use +00109 uint8 laAlignRaw[sizeof(CLookAtAlign) * CPSQuad::quadBufSize]; // orientation computed from motion for each particle +00110 CLookAtAlign *laAlign = (CLookAtAlign *) laAlignRaw; // cast to avoid unilined ctor calls +00111 float *currentSize; +00112 uint32 currentSizeStep = la._SizeScheme ? 1 : 0; +00113 // point the vector part in the current vertex +00114 uint8 *ptPos; +00115 // strides to go from one vertex to another one +00116 const uint32 stride = vb.getVertexSize(), stride2 = stride << 1, stride3 = stride + stride2, stride4 = stride << 2; +00117 if (!la._Angle2DScheme) +00118 { +00119 // constant rotation case +00120 do +00121 { +00122 // restart at the beginning of the vertex buffer +00123 ptPos = (uint8 *) vb.getVertexCoordPointer(); +00124 toProcess = leftToDo <= CPSQuad::quadBufSize ? leftToDo : CPSQuad::quadBufSize; +00125 +00126 if (la._SizeScheme) +00127 { +00128 currentSize = (float *) la._SizeScheme->make(la._Owner, size- leftToDo, pSizes, sizeof(float), toProcess, true, srcStep); +00129 } +00130 else +00131 { +00132 currentSize = &la._ParticleSize; +00133 } +00134 computeOrientationVectors(speedIt, I, K, laAlign, toProcess); +00135 speedIt = speedIt + toProcess; +00136 const CLookAtAlign *currAlign = laAlign; +00137 +00138 la.updateVbColNUVForRender(vb, size - leftToDo, toProcess, srcStep); +00139 T endIt = it + toProcess; +00140 if (!la._IndependantSizes) +00141 { +00142 const uint32 tabIndex = (((uint32) la._Angle2D) & 0xff) << 2; +00143 CVector v1; +00144 CVector v2; +00145 // TODO : optimize if necessary +00146 while (it != endIt) +00147 { +00148 v1 = rotTable[tabIndex] * currAlign->I + rotTable[tabIndex + 1] * currAlign->K; +00149 v2 = rotTable[tabIndex + 2] * currAlign->I + rotTable[tabIndex + 3] * currAlign->K; +00150 CHECK_VERTEX_BUFFER(vb, ptPos); +00151 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x; +00152 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y; +00153 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z; +00154 ptPos += stride; +00155 +00156 CHECK_VERTEX_BUFFER(vb, ptPos); +00157 ((CVector *) ptPos)->x = (*it).x + *currentSize * v2.x; +00158 ((CVector *) ptPos)->y = (*it).y + *currentSize * v2.y; +00159 ((CVector *) ptPos)->z = (*it).z + *currentSize * v2.z; +00160 ptPos += stride; +00161 +00162 CHECK_VERTEX_BUFFER(vb, ptPos); +00163 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x; +00164 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y; +00165 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z; +00166 ptPos += stride; +00167 +00168 CHECK_VERTEX_BUFFER(vb, ptPos); +00169 ((CVector *) ptPos)->x = (*it).x - *currentSize * v2.x; +00170 ((CVector *) ptPos)->y = (*it).y - *currentSize * v2.y; +00171 ((CVector *) ptPos)->z = (*it).z - *currentSize * v2.z; +00172 ptPos += stride; +00173 +00174 ++it; +00175 ++currAlign; +00176 currentSize += currentSizeStep; +00177 } +00178 } +00179 else // independant sizes +00180 { +00181 float *currentSize2; +00182 float secondSize; +00183 uint32 currentSizeStep2; +00184 if (la._SecondSize.getSizeScheme()) +00185 { +00186 currentSize2 = (float *) la._SecondSize.getSizeScheme()->make(la._Owner, size- leftToDo, pSecondSizes, sizeof(float), toProcess, true, srcStep); +00187 currentSizeStep2 = 1; +00188 } +00189 else +00190 { +00191 secondSize = la._SecondSize.getSize(); +00192 currentSize2 = &secondSize; +00193 currentSizeStep2 = 0; +00194 } +00195 CVector v1; +00196 CVector v2; +00197 // TODO : optimize if necessary +00198 while (it != endIt) +00199 { +00200 v1 = CPSUtil::getCos((sint32) la._Angle2D) * currAlign->I + CPSUtil::getSin((sint32) la._Angle2D) * currAlign->K; +00201 v2 = - CPSUtil::getSin((sint32) la._Angle2D) * currAlign->I + CPSUtil::getCos((sint32) la._Angle2D) * currAlign->K; +00202 CHECK_VERTEX_BUFFER(vb, ptPos); +00203 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x + *currentSize2 * v2.x; +00204 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y + *currentSize2 * v2.y; +00205 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z + *currentSize2 * v2.z; +00206 ptPos += stride; +00207 +00208 CHECK_VERTEX_BUFFER(vb, ptPos); +00209 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x + *currentSize2 * v2.x; +00210 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y + *currentSize2 * v2.y; +00211 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z + *currentSize2 * v2.z; +00212 ptPos += stride; +00213 +00214 CHECK_VERTEX_BUFFER(vb, ptPos); +00215 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x - *currentSize2 * v2.x; +00216 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y - *currentSize2 * v2.y; +00217 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z - *currentSize2 * v2.z; +00218 ptPos += stride; +00219 +00220 CHECK_VERTEX_BUFFER(vb, ptPos); +00221 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x - *currentSize2 * v2.x; +00222 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y - *currentSize2 * v2.y; +00223 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z - *currentSize2 * v2.z; +00224 ptPos += stride; +00225 ++it; +00226 ++currAlign; +00227 currentSize += currentSizeStep; +00228 currentSize2 += currentSizeStep2; +00229 } +00230 } +00231 // uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00232 driver->renderQuads(la._Mat, 0, toProcess); +00233 // PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick; +00234 leftToDo -= toProcess; +00235 } +00236 while (leftToDo); +00237 } +00238 else +00239 { +00240 float pAngles[CPSQuad::quadBufSize]; // the angles to use +00241 float *currentAngle; +00242 do +00243 { +00244 // restart at the beginning of the vertex buffer +00245 ptPos = (uint8 *) vb.getVertexCoordPointer(); +00246 toProcess = leftToDo <= CPSQuad::quadBufSize ? leftToDo : CPSQuad::quadBufSize; +00247 if (la._SizeScheme) +00248 { +00249 currentSize = (float *) la._SizeScheme->make(la._Owner, size - leftToDo, pSizes, sizeof(float), toProcess, true, srcStep); +00250 } +00251 else +00252 { +00253 currentSize = &la._ParticleSize; +00254 } +00255 computeOrientationVectors(speedIt, I, K, laAlign, toProcess); +00256 speedIt = speedIt + toProcess; +00257 const CLookAtAlign *currAlign = laAlign; +00258 currentAngle = (float *) la._Angle2DScheme->make(la._Owner, size - leftToDo, pAngles, sizeof(float), toProcess, true, srcStep); +00259 la.updateVbColNUVForRender(vb, size - leftToDo, toProcess, srcStep); +00260 T endIt = it + toProcess; +00261 CVector v1, v2; +00262 NLMISC::OptFastFloorBegin(); +00263 if (!la._IndependantSizes) +00264 { +00265 while (it != endIt) +00266 { +00267 const uint32 tabIndex = ((NLMISC::OptFastFloor(*currentAngle)) & 0xff) << 2; +00268 // lets avoid some ctor calls +00269 v1.x = *currentSize * (rotTable[tabIndex] * currAlign->I.x + rotTable[tabIndex + 1] * currAlign->K.x); +00270 v1.y = *currentSize * (rotTable[tabIndex] * currAlign->I.y + rotTable[tabIndex + 1] * currAlign->K.y); +00271 v1.z = *currentSize * (rotTable[tabIndex] * currAlign->I.z + rotTable[tabIndex + 1] * currAlign->K.z); +00272 +00273 v2.x = *currentSize * (rotTable[tabIndex + 2] * currAlign->I.x + rotTable[tabIndex + 3] * currAlign->K.x); +00274 v2.y = *currentSize * (rotTable[tabIndex + 2] * currAlign->I.y + rotTable[tabIndex + 3] * currAlign->K.y); +00275 v2.z = *currentSize * (rotTable[tabIndex + 2] * currAlign->I.z + rotTable[tabIndex + 3] * currAlign->K.z); +00276 +00277 CHECK_VERTEX_BUFFER(vb, ptPos); +00278 CHECK_VERTEX_BUFFER(vb, ptPos + stride); +00279 CHECK_VERTEX_BUFFER(vb, ptPos + stride2); +00280 CHECK_VERTEX_BUFFER(vb, ptPos + stride3); +00281 +00282 ((CVector *) ptPos)->x = (*it).x + v1.x; +00283 ((CVector *) ptPos)->y = (*it).y + v1.y; +00284 ((CVector *) ptPos)->z = (*it).z + v1.z; +00285 ptPos += stride; +00286 +00287 ((CVector *) ptPos)->x = (*it).x + v2.x; +00288 ((CVector *) ptPos)->y = (*it).y + v2.y; +00289 ((CVector *) ptPos)->z = (*it).z + v2.z; +00290 ptPos += stride; +00291 +00292 ((CVector *) ptPos)->x = (*it).x - v1.x; +00293 ((CVector *) ptPos)->y = (*it).y - v1.y; +00294 ((CVector *) ptPos)->z = (*it).z - v1.z; +00295 ptPos += stride; +00296 +00297 ((CVector *) ptPos)->x = (*it).x - v2.x; +00298 ((CVector *) ptPos)->y = (*it).y - v2.y; +00299 ((CVector *) ptPos)->z = (*it).z - v2.z; +00300 ptPos += stride; +00301 +00302 ++it; +00303 ++ currAlign; +00304 currentSize += currentSizeStep; +00305 ++currentAngle; +00306 } +00307 } +00308 else // independant size, and non-constant rotation +00309 { +00310 +00311 float *currentSize2; +00312 float secondSize; +00313 uint32 currentSizeStep2; +00314 if (la._SecondSize.getSizeScheme()) +00315 { +00316 currentSize2 = (float *) la._SecondSize.getSizeScheme()->make(la._Owner, size- leftToDo, pSecondSizes, sizeof(float), toProcess, true, srcStep); +00317 currentSizeStep2 = 1; +00318 } +00319 else +00320 { +00321 secondSize = la._SecondSize.getSize(); +00322 currentSize2 = &secondSize; +00323 currentSizeStep2 = 0; +00324 } +00325 +00326 float cosAngle, sinAngle; +00327 while (it != endIt) +00328 { +00329 cosAngle = CPSUtil::getCos((sint32) *currentAngle); +00330 sinAngle = CPSUtil::getSin((sint32) *currentAngle); +00331 v1 = cosAngle * currAlign->I + sinAngle * currAlign->K; +00332 v2 = - sinAngle * currAlign->I + cosAngle * currAlign->K; +00333 +00334 CHECK_VERTEX_BUFFER(vb, ptPos); +00335 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x + *currentSize2 * v2.x; +00336 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y + *currentSize2 * v2.y; +00337 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z + *currentSize2 * v2.z; +00338 ptPos += stride; +00339 +00340 CHECK_VERTEX_BUFFER(vb, ptPos); +00341 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x + *currentSize2 * v2.x; +00342 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y + *currentSize2 * v2.y; +00343 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z + *currentSize2 * v2.z; +00344 ptPos += stride; +00345 +00346 CHECK_VERTEX_BUFFER(vb, ptPos); +00347 ((CVector *) ptPos)->x = (*it).x + *currentSize * v1.x - *currentSize2 * v2.x; +00348 ((CVector *) ptPos)->y = (*it).y + *currentSize * v1.y - *currentSize2 * v2.y; +00349 ((CVector *) ptPos)->z = (*it).z + *currentSize * v1.z - *currentSize2 * v2.z; +00350 ptPos += stride; +00351 +00352 CHECK_VERTEX_BUFFER(vb, ptPos); +00353 ((CVector *) ptPos)->x = (*it).x - *currentSize * v1.x - *currentSize2 * v2.x; +00354 ((CVector *) ptPos)->y = (*it).y - *currentSize * v1.y - *currentSize2 * v2.y; +00355 ((CVector *) ptPos)->z = (*it).z - *currentSize * v1.z - *currentSize2 * v2.z; +00356 ptPos += stride; +00357 ++it; +00358 ++currentAngle; +00359 ++ currAlign; +00360 currentSize += currentSizeStep; +00361 currentSize2 += currentSizeStep2; +00362 } +00363 } +00364 NLMISC::OptFastFloorEnd(); +00365 //tmp +00366 // uint64 startTick = NLMISC::CTime::getPerformanceTime(); +00367 driver->renderQuads(la._Mat, 0, toProcess); +00368 // PSLookAtRenderTime += NLMISC::CTime::getPerformanceTime() - startTick; +00369 leftToDo -= toProcess; +00370 } +00371 while (leftToDo); +00372 } +00373 PARTICLES_CHECK_MEM; +00374 } +

+

The documentation for this class was generated from the following file:

ps_face_look_at.cpp

Generated on Tue Mar 16 07:12:22 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Static Public Member Functions
template<class T> void	computeOrientationVectors (T speedIt, const CVector &I, const CVector &K, CLookAtAlign *dest, uint size)
template<class T> void	drawLookAt (T it, T speedIt, CPSFaceLookAt &la, uint size, uint32 srcStep)
template<class T> void	drawLookAtAlignOnMotion (T it, T speedIt, CPSFaceLookAt &la, uint size, uint32 srcStep)