开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llflexibleobject.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：26k
源码类别：

游戏引擎

开发平台：

C++ Builder

llflexibleobject.cpp：源码内容
  1. /** 
  2.  * @file llflexibleobject.cpp
  3.  * @brief Flexible object implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2006-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "pipeline.h"
  36. #include "lldrawpoolbump.h"
  37. #include "llface.h"
  38. #include "llflexibleobject.h"
  39. #include "llglheaders.h"
  40. #include "llrendersphere.h"
  41. #include "llviewerobject.h"
  42. #include "llagent.h"
  43. #include "llsky.h"
  44. #include "llviewercamera.h"
  45. #include "llviewertexturelist.h"
  46. #include "llviewercontrol.h"
  47. #include "llviewerobjectlist.h"
  48. #include "llviewerregion.h"
  49. #include "llworld.h"
  50. #include "llvoavatar.h"
  52. /*static*/ F32 LLVolumeImplFlexible::sUpdateFactor = 1.0f;
  54. // LLFlexibleObjectData::pack/unpack now in llprimitive.cpp
  56. //-----------------------------------------------
  57. // constructor
  58. //-----------------------------------------------
  59. LLVolumeImplFlexible::LLVolumeImplFlexible(LLViewerObject* vo, LLFlexibleObjectData* attributes) :
  60. mVO(vo), mAttributes(attributes)
  61. {
  62. static U32 seed = 0;
  63. mID = seed++;
  64. mInitialized = FALSE;
  65. mUpdated = FALSE;
  66. mInitializedRes = -1;
  67. mSimulateRes = 0;
  68. mFrameNum = 0;
  69. mCollisionSphereRadius = 0.f;
  70. mRenderRes = 1;
  72. if(mVO->mDrawable.notNull())
  73. {
  74. mVO->mDrawable->makeActive() ;
  75. }
  76. }//-----------------------------------------------
  78. LLVector3 LLVolumeImplFlexible::getFramePosition() const
  79. {
  80. return mVO->getRenderPosition();
  81. }
  83. LLQuaternion LLVolumeImplFlexible::getFrameRotation() const
  84. {
  85. return mVO->getRenderRotation();
  86. }
  88. void LLVolumeImplFlexible::onParameterChanged(U16 param_type, LLNetworkData *data, BOOL in_use, bool local_origin)
  89. {
  90. if (param_type == LLNetworkData::PARAMS_FLEXIBLE)
  91. {
  92. mAttributes = (LLFlexibleObjectData*)data;
  93. setAttributesOfAllSections();
  94. }
  95. }
  97. void LLVolumeImplFlexible::onShift(const LLVector3 &shift_vector)
  98. {
  99. for (int section = 0; section < (1<<FLEXIBLE_OBJECT_MAX_SECTIONS)+1; ++section)
  100. {
  101. mSection[section].mPosition += shift_vector;
  102. }
  103. }
  105. //-----------------------------------------------------------------------------------------------
  106. void LLVolumeImplFlexible::setParentPositionAndRotationDirectly( LLVector3 p, LLQuaternion r )
  107. {
  108. mParentPosition = p;
  109. mParentRotation = r;
  111. }//-----------------------------------------------------------------------------------------------------
  113. void LLVolumeImplFlexible::remapSections(LLFlexibleObjectSection *source, S32 source_sections,
  114.  LLFlexibleObjectSection *dest, S32 dest_sections)
  115. {
  116. S32 num_output_sections = 1<<dest_sections;
  117. LLVector3 scale = mVO->mDrawable->getScale();
  118. F32 source_section_length = scale.mV[VZ] / (F32)(1<<source_sections);
  119. F32 section_length = scale.mV[VZ] / (F32)num_output_sections;
  120. if (source_sections == -1)
  121. {
  122. // Generate all from section 0
  123. dest[0] = source[0];
  124. for (S32 section=0; section<num_output_sections; ++section)
  125. {
  126. dest[section+1] = dest[section];
  127. dest[section+1].mPosition += dest[section].mDirection * section_length;
  128. dest[section+1].mVelocity.setVec( LLVector3::zero );
  129. }
  130. }
  131. else if (source_sections > dest_sections)
  132. {
  133. // Copy, skipping sections
  135. S32 num_steps = 1<<(source_sections-dest_sections);
  137. // Copy from left to right since it may be an in-place computation
  138. for (S32 section=0; section<num_output_sections; ++section)
  139. {
  140. dest[section+1] = source[(section+1)*num_steps];
  141. }
  142. dest[0] = source[0];
  143. }
  144. else if (source_sections < dest_sections)
  145. {
  146. // Interpolate section info
  147. // Iterate from right to left since it may be an in-place computation
  148. S32 step_shift = dest_sections-source_sections;
  149. S32 num_steps = 1<<step_shift;
  150. for (S32 section=num_output_sections-num_steps; section>=0; section -= num_steps)
  151. {
  152. LLFlexibleObjectSection *last_source_section = &source[section>>step_shift];
  153. LLFlexibleObjectSection *source_section = &source[(section>>step_shift)+1];
  155. // Cubic interpolation of position
  156. // At^3 + Bt^2 + Ct + D = f(t)
  157. LLVector3 D = last_source_section->mPosition;
  158. LLVector3 C = last_source_section->mdPosition * source_section_length;
  159. LLVector3 Y = source_section->mdPosition * source_section_length - C; // Helper var
  160. LLVector3 X = (source_section->mPosition - D - C); // Helper var
  161. LLVector3 A = Y - 2*X;
  162. LLVector3 B = X - A;
  164. F32 t_inc = 1.f/F32(num_steps);
  165. F32 t = t_inc;
  166. for (S32 step=1; step<num_steps; ++step)
  167. {
  168. dest[section+step].mScale = 
  169. lerp(last_source_section->mScale, source_section->mScale, t);
  170. dest[section+step].mAxisRotation = 
  171. slerp(t, last_source_section->mAxisRotation, source_section->mAxisRotation);
  173. // Evaluate output interpolated values
  174. F32 t_sq = t*t;
  175. dest[section+step].mPosition = t_sq*(t*A + B) + t*C + D;
  176. dest[section+step].mRotation = 
  177. slerp(t, last_source_section->mRotation, source_section->mRotation);
  178. dest[section+step].mVelocity = lerp(last_source_section->mVelocity, source_section->mVelocity, t);
  179. dest[section+step].mDirection = lerp(last_source_section->mDirection, source_section->mDirection, t);
  180. dest[section+step].mdPosition = lerp(last_source_section->mdPosition, source_section->mdPosition, t);
  181. dest[section+num_steps] = *source_section;
  182. t += t_inc;
  183. }
  184. }
  185. dest[0] = source[0];
  186. }
  187. else
  188. {
  189. // numbers are equal. copy info
  190. for (S32 section=0; section <= num_output_sections; ++section)
  191. {
  192. dest[section] = source[section];
  193. }
  194. }
  195. }
  198. //-----------------------------------------------------------------------------
  199. void LLVolumeImplFlexible::setAttributesOfAllSections(LLVector3* inScale)
  200. {
  201. LLVector2 bottom_scale, top_scale;
  202. F32 begin_rot = 0, end_rot = 0;
  203. if (mVO->getVolume())
  204. {
  205. const LLPathParams &params = mVO->getVolume()->getParams().getPathParams();
  206. bottom_scale = params.getBeginScale();
  207. top_scale = params.getEndScale();
  208. begin_rot = F_PI * params.getTwistBegin();
  209. end_rot = F_PI * params.getTwist();
  210. }
  212. if (!mVO->mDrawable)
  213. {
  214. return;
  215. }
  217. S32 num_sections = 1 << mSimulateRes;
  219. LLVector3 scale;
  220. if (inScale == (LLVector3*)NULL)
  221. {
  222. scale = mVO->mDrawable->getScale();
  223. }
  224. else
  225. {
  226. scale = *inScale;
  227. }
  229. mSection[0].mPosition = getAnchorPosition();
  230. mSection[0].mDirection = LLVector3::z_axis * getFrameRotation();
  231. mSection[0].mdPosition = mSection[0].mDirection;
  232. mSection[0].mScale.setVec(scale.mV[VX]*bottom_scale.mV[0], scale.mV[VY]*bottom_scale.mV[1]);
  233. mSection[0].mVelocity.setVec(0,0,0);
  234. mSection[0].mAxisRotation.setQuat(begin_rot,0,0,1);
  236. LLVector3 parentSectionPosition = mSection[0].mPosition;
  237. LLVector3 last_direction = mSection[0].mDirection;
  239. remapSections(mSection, mInitializedRes, mSection, mSimulateRes);
  240. mInitializedRes = mSimulateRes;
  242. F32 t_inc = 1.f/F32(num_sections);
  243. F32 t = t_inc;
  245. for ( int i=1; i<= num_sections; i++)
  246. {
  247. mSection[i].mAxisRotation.setQuat(lerp(begin_rot,end_rot,t),0,0,1);
  248. mSection[i].mScale = LLVector2(
  249. scale.mV[VX] * lerp(bottom_scale.mV[0], top_scale.mV[0], t), 
  250. scale.mV[VY] * lerp(bottom_scale.mV[1], top_scale.mV[1], t));
  251. t += t_inc;
  252. }
  253. }//-----------------------------------------------------------------------------------
  256. void LLVolumeImplFlexible::onSetVolume(const LLVolumeParams &volume_params, const S32 detail)
  257. {
  258. }
  260. //---------------------------------------------------------------------------------
  261. // This calculates the physics of the flexible object. Note that it has to be 0
  262. // updated every time step. In the future, perhaps there could be an 
  263. // optimization similar to what Havok does for objects that are stationary. 
  264. //---------------------------------------------------------------------------------
  265. static LLFastTimer::DeclareTimer FTM_FLEXIBLE_UPDATE("Update Flexies");
  266. BOOL LLVolumeImplFlexible::doIdleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  267. {
  268. if (mVO->mDrawable.isNull())
  269. {
  270. // Don't do anything until we have a drawable
  271. return FALSE; // (we are not initialized or updated)
  272. }
  274. BOOL force_update = mSimulateRes == 0 ? TRUE : FALSE;
  276. //flexible objects never go static
  277. mVO->mDrawable->mQuietCount = 0;
  278. if (!mVO->mDrawable->isRoot())
  279. {
  280. LLViewerObject* parent = (LLViewerObject*) mVO->getParent();
  281. parent->mDrawable->mQuietCount = 0;
  282. }
  284. LLFastTimer ftm(FTM_FLEXIBLE_UPDATE);
  286. S32 new_res = mAttributes->getSimulateLOD();
  288. //number of segments only cares about z axis
  289. F32 app_angle = llround((F32) atan2( mVO->getScale().mV[2]*2.f, mVO->mDrawable->mDistanceWRTCamera) * RAD_TO_DEG, 0.01f);
  291. // Rendering sections increases with visible angle on the screen
  292. mRenderRes = (S32)(FLEXIBLE_OBJECT_MAX_SECTIONS*4*app_angle*DEG_TO_RAD/LLViewerCamera::getInstance()->getView());
  293. if (mRenderRes > FLEXIBLE_OBJECT_MAX_SECTIONS)
  294. {
  295. mRenderRes = FLEXIBLE_OBJECT_MAX_SECTIONS;
  296. }
  299. // Bottom cap at 1/4 the original number of sections
  300. if (mRenderRes < mAttributes->getSimulateLOD()-1)
  301. {
  302. mRenderRes = mAttributes->getSimulateLOD()-1;
  303. }
  304. // Throttle back simulation of segments we're not rendering
  305. if (mRenderRes < new_res)
  306. {
  307. new_res = mRenderRes;
  308. }
  310. if (!mInitialized || (mSimulateRes != new_res))
  311. {
  312. mSimulateRes = new_res;
  313. setAttributesOfAllSections();
  314. mInitialized = TRUE;
  315. }
  316. if (!gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FLEXIBLE))
  317. {
  318. return FALSE; // (we are not initialized or updated)
  319. }
  321. if (force_update)
  322. {
  323. gPipeline.markRebuild(mVO->mDrawable, LLDrawable::REBUILD_POSITION, FALSE);
  324. }
  325. else if (mVO->mDrawable->isVisible() &&
  326. !mVO->mDrawable->isState(LLDrawable::IN_REBUILD_Q1) &&
  327. mVO->getPixelArea() > 256.f)
  328. {
  329. U32 id;
  330. F32 pixel_area = mVO->getPixelArea();
  332. if (mVO->isRootEdit())
  333. {
  334. id = mID;
  335. }
  336. else
  337. {
  338. LLVOVolume* parent = (LLVOVolume*) mVO->getParent();
  339. id = parent->getVolumeInterfaceID();
  340. }
  342. U32 update_period = (U32) (LLViewerCamera::getInstance()->getScreenPixelArea()*0.01f/(pixel_area*(sUpdateFactor+1.f)))+1;
  344. if ((LLDrawable::getCurrentFrame()+id)%update_period == 0)
  345. {
  346. gPipeline.markRebuild(mVO->mDrawable, LLDrawable::REBUILD_POSITION, FALSE);
  347. }
  348. }
  350. return force_update;
  351. }
  353. inline S32 log2(S32 x)
  354. {
  355. S32 ret = 0;
  356. while (x > 1)
  357. {
  358. ++ret;
  359. x >>= 1;
  360. }
  361. return ret;
  362. }
  364. void LLVolumeImplFlexible::doFlexibleUpdate()
  365. {
  366. LLVolume* volume = mVO->getVolume();
  367. LLPath *path = &volume->getPath();
  368. if (mSimulateRes == 0)
  369. {
  370. mVO->markForUpdate(TRUE);
  371. if (!doIdleUpdate(gAgent, *LLWorld::getInstance(), 0.0))
  372. {
  373. return; // we did not get updated or initialized, proceeding without can be dangerous
  374. }
  375. }
  377. llassert_always(mInitialized);
  379. S32 num_sections = 1 << mSimulateRes;
  381.     F32 secondsThisFrame = mTimer.getElapsedTimeAndResetF32();
  382. if (secondsThisFrame > 0.2f)
  383. {
  384. secondsThisFrame = 0.2f;
  385. }
  387. LLVector3 BasePosition = getFramePosition();
  388. LLQuaternion BaseRotation = getFrameRotation();
  389. LLQuaternion parentSegmentRotation = BaseRotation;
  390. LLVector3 anchorDirectionRotated = LLVector3::z_axis * parentSegmentRotation;
  391. LLVector3 anchorScale = mVO->mDrawable->getScale();
  393. F32 section_length = anchorScale.mV[VZ] / (F32)num_sections;
  394. F32 inv_section_length = 1.f / section_length;
  396. S32 i;
  398. // ANCHOR position is offset from BASE position (centroid) by half the length
  399. LLVector3 AnchorPosition = BasePosition - (anchorScale.mV[VZ]/2 * anchorDirectionRotated);
  401. mSection[0].mPosition = AnchorPosition;
  402. mSection[0].mDirection = anchorDirectionRotated;
  403. mSection[0].mRotation = BaseRotation;
  405. LLQuaternion deltaRotation;
  407. LLVector3 lastPosition;
  409. // Coefficients which are constant across sections
  410. F32 t_factor = mAttributes->getTension() * 0.1f;
  411. t_factor = t_factor*(1 - pow(0.85f, secondsThisFrame*30));
  412. if ( t_factor > FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE )
  413. {
  414. t_factor = FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE;
  415. }
  417. F32 friction_coeff = (mAttributes->getAirFriction()*2+1);
  418. friction_coeff = pow(10.f, friction_coeff*secondsThisFrame);
  419. friction_coeff = (friction_coeff > 1) ? friction_coeff : 1;
  420. F32 momentum = 1.0f / friction_coeff;
  422. F32 wind_factor = (mAttributes->getWindSensitivity()*0.1f) * section_length * secondsThisFrame;
  423. F32 max_angle = atan(section_length*2.f);
  425. F32 force_factor = section_length * secondsThisFrame;
  427. // Update simulated sections
  428. for (i=1; i<=num_sections; ++i)
  429. {
  430. LLVector3 parentSectionVector;
  431. LLVector3 parentSectionPosition;
  432. LLVector3 parentDirection;
  434. //---------------------------------------------------
  435. // save value of position as lastPosition
  436. //---------------------------------------------------
  437. lastPosition = mSection[i].mPosition;
  439. //------------------------------------------------------------------------------------------
  440. // gravity
  441. //------------------------------------------------------------------------------------------
  442. mSection[i].mPosition.mV[2] -= mAttributes->getGravity() * force_factor;
  444. //------------------------------------------------------------------------------------------
  445. // wind force
  446. //------------------------------------------------------------------------------------------
  447. if (mAttributes->getWindSensitivity() > 0.001f)
  448. {
  449. mSection[i].mPosition += gAgent.getRegion()->mWind.getVelocity( mSection[i].mPosition ) * wind_factor;
  450. }
  452. //------------------------------------------------------------------------------------------
  453. // user-defined force
  454. //------------------------------------------------------------------------------------------
  455. mSection[i].mPosition += mAttributes->getUserForce() * force_factor;
  457. //---------------------------------------------------
  458. // tension (rigidity, stiffness)
  459. //---------------------------------------------------
  460. parentSectionPosition = mSection[i-1].mPosition;
  461. parentDirection = mSection[i-1].mDirection;
  463. if ( i == 1 )
  464. {
  465. parentSectionVector = mSection[0].mDirection;
  466. }
  467. else
  468. {
  469. parentSectionVector = mSection[i-2].mDirection;
  470. }
  472. LLVector3 currentVector = mSection[i].mPosition - parentSectionPosition;
  474. LLVector3 difference = (parentSectionVector*section_length) - currentVector;
  475. LLVector3 tensionForce = difference * t_factor;
  477. mSection[i].mPosition += tensionForce;
  479. //------------------------------------------------------------------------------------------
  480. // sphere collision, currently not used
  481. //------------------------------------------------------------------------------------------
  482. /*if ( mAttributes->mUsingCollisionSphere )
  483. {
  484. LLVector3 vectorToCenterOfCollisionSphere = mCollisionSpherePosition - mSection[i].mPosition;
  485. if ( vectorToCenterOfCollisionSphere.magVecSquared() < mCollisionSphereRadius * mCollisionSphereRadius )
  486. {
  487. F32 distanceToCenterOfCollisionSphere = vectorToCenterOfCollisionSphere.magVec();
  488. F32 penetration = mCollisionSphereRadius - distanceToCenterOfCollisionSphere;
  490. LLVector3 normalToCenterOfCollisionSphere;
  492. if ( distanceToCenterOfCollisionSphere > 0.0f )
  493. {
  494. normalToCenterOfCollisionSphere = vectorToCenterOfCollisionSphere / distanceToCenterOfCollisionSphere;
  495. }
  496. else // rare
  497. {
  498. normalToCenterOfCollisionSphere = LLVector3::x_axis; // arbitrary
  499. }
  501. // push the position out to the surface of the collision sphere
  502. mSection[i].mPosition -= normalToCenterOfCollisionSphere * penetration;
  503. }
  504. }*/
  506. //------------------------------------------------------------------------------------------
  507. // inertia
  508. //------------------------------------------------------------------------------------------
  509. mSection[i].mPosition += mSection[i].mVelocity * momentum;
  511. //------------------------------------------------------------------------------------------
  512. // clamp length & rotation
  513. //------------------------------------------------------------------------------------------
  514. mSection[i].mDirection = mSection[i].mPosition - parentSectionPosition;
  515. mSection[i].mDirection.normVec();
  516. deltaRotation.shortestArc( parentDirection, mSection[i].mDirection );
  518. F32 angle;
  519. LLVector3 axis;
  520. deltaRotation.getAngleAxis(&angle, axis);
  521. if (angle > F_PI) angle -= 2.f*F_PI;
  522. if (angle < -F_PI) angle += 2.f*F_PI;
  523. if (angle > max_angle)
  524. {
  525. //angle = 0.5f*(angle+max_angle);
  526. deltaRotation.setQuat(max_angle, axis);
  527. } else if (angle < -max_angle)
  528. {
  529. //angle = 0.5f*(angle-max_angle);
  530. deltaRotation.setQuat(-max_angle, axis);
  531. }
  532. LLQuaternion segment_rotation = parentSegmentRotation * deltaRotation;
  533. parentSegmentRotation = segment_rotation;
  535. mSection[i].mDirection = (parentDirection * deltaRotation);
  536. mSection[i].mPosition = parentSectionPosition + mSection[i].mDirection * section_length;
  537. mSection[i].mRotation = segment_rotation;
  539. if (i > 1)
  540. {
  541. // Propogate half the rotation up to the parent
  542. LLQuaternion halfDeltaRotation(angle/2, axis);
  543. mSection[i-1].mRotation = mSection[i-1].mRotation * halfDeltaRotation;
  544. }
  546. //------------------------------------------------------------------------------------------
  547. // calculate velocity
  548. //------------------------------------------------------------------------------------------
  549. mSection[i].mVelocity = mSection[i].mPosition - lastPosition;
  550. if (mSection[i].mVelocity.magVecSquared() > 1.f)
  551. {
  552. mSection[i].mVelocity.normVec();
  553. }
  554. }
  556. // Calculate derivatives (not necessary until normals are automagically generated)
  557. mSection[0].mdPosition = (mSection[1].mPosition - mSection[0].mPosition) * inv_section_length;
  558. // i = 1..NumSections-1
  559. for (i=1; i<num_sections; ++i)
  560. {
  561. // Quadratic numerical derivative of position
  563. // f(-L1) = aL1^2 - bL1 + c = f1
  564. // f(0)   =               c = f2
  565. // f(L2)  = aL2^2 + bL2 + c = f3
  566. // f = ax^2 + bx + c
  567. // d/dx f = 2ax + b
  568. // d/dx f(0) = b
  570. // c = f2
  571. // a = [(f1-c)/L1 + (f3-c)/L2] / (L1+L2)
  572. // b = (f3-c-aL2^2)/L2
  574. LLVector3 a = (mSection[i-1].mPosition-mSection[i].mPosition +
  575. mSection[i+1].mPosition-mSection[i].mPosition) * 0.5f * inv_section_length * inv_section_length;
  576. LLVector3 b = (mSection[i+1].mPosition-mSection[i].mPosition - a*(section_length*section_length));
  577. b *= inv_section_length;
  579. mSection[i].mdPosition = b;
  580. }
  582. // i = NumSections
  583. mSection[i].mdPosition = (mSection[i].mPosition - mSection[i-1].mPosition) * inv_section_length;
  585. // Create points
  586. S32 num_render_sections = 1<<mRenderRes;
  587. if (path->getPathLength() != num_render_sections+1)
  588. {
  589. ((LLVOVolume*) mVO)->mVolumeChanged = TRUE;
  590. volume->resizePath(num_render_sections+1);
  591. }
  593. LLPath::PathPt *new_point;
  595. LLFlexibleObjectSection newSection[ (1<<FLEXIBLE_OBJECT_MAX_SECTIONS)+1 ];
  596. remapSections(mSection, mSimulateRes, newSection, mRenderRes);
  598. //generate transform from global to prim space
  599. LLVector3 delta_scale = LLVector3(1,1,1);
  600. LLVector3 delta_pos;
  601. LLQuaternion delta_rot;
  603. delta_rot = ~getFrameRotation();
  604. delta_pos = -getFramePosition()*delta_rot;
  606. // Vertex transform (4x4)
  607. LLVector3 x_axis = LLVector3(delta_scale.mV[VX], 0.f, 0.f) * delta_rot;
  608. LLVector3 y_axis = LLVector3(0.f, delta_scale.mV[VY], 0.f) * delta_rot;
  609. LLVector3 z_axis = LLVector3(0.f, 0.f, delta_scale.mV[VZ]) * delta_rot;
  611. LLMatrix4 rel_xform;
  612. rel_xform.initRows(LLVector4(x_axis, 0.f),
  613. LLVector4(y_axis, 0.f),
  614. LLVector4(z_axis, 0.f),
  615. LLVector4(delta_pos, 1.f));
  617. for (i=0; i<=num_render_sections; ++i)
  618. {
  619. new_point = &path->mPath[i];
  620. LLVector3 pos = newSection[i].mPosition * rel_xform;
  621. LLQuaternion rot = mSection[i].mAxisRotation * newSection[i].mRotation * delta_rot;
  623. if (!mUpdated || (new_point->mPos-pos).magVec()/mVO->mDrawable->mDistanceWRTCamera > 0.001f)
  624. {
  625. new_point->mPos = newSection[i].mPosition * rel_xform;
  626. mUpdated = FALSE;
  627. }
  629. new_point->mRot = rot;
  630. new_point->mScale = newSection[i].mScale;
  631. new_point->mTexT = ((F32)i)/(num_render_sections);
  632. }
  634. mLastSegmentRotation = parentSegmentRotation;
  635. }
  637. void LLVolumeImplFlexible::preRebuild()
  638. {
  639. if (!mUpdated)
  640. {
  641. doFlexibleRebuild();
  642. }
  643. }
  645. void LLVolumeImplFlexible::doFlexibleRebuild()
  646. {
  647. LLVolume* volume = mVO->getVolume();
  648. volume->regen();
  650. mUpdated = TRUE;
  651. }
  653. //------------------------------------------------------------------
  655. void LLVolumeImplFlexible::onSetScale(const LLVector3& scale, BOOL damped)
  656. {
  657. setAttributesOfAllSections((LLVector3*) &scale);
  658. }
  660. BOOL LLVolumeImplFlexible::doUpdateGeometry(LLDrawable *drawable)
  661. {
  662. LLVOVolume *volume = (LLVOVolume*)mVO;
  664. if (mVO->isAttachment())
  665. { //don't update flexible attachments for impostored avatars unless the 
  666. //impostor is being updated this frame (w00!)
  667. LLViewerObject* parent = (LLViewerObject*) mVO->getParent();
  668. while (parent && !parent->isAvatar())
  669. {
  670. parent = (LLViewerObject*) parent->getParent();
  671. }
  673. if (parent)
  674. {
  675. LLVOAvatar* avatar = (LLVOAvatar*) parent;
  676. if (avatar->isImpostor() && !avatar->needsImpostorUpdate())
  677. {
  678. return TRUE;
  679. }
  680. }
  681. }
  683. if (volume->mDrawable.isNull())
  684. {
  685. return TRUE; // No update to complete
  686. }
  688. if (volume->mLODChanged)
  689. {
  690. LLVolumeParams volume_params = volume->getVolume()->getParams();
  691. volume->setVolume(volume_params, 0);
  692. mUpdated = FALSE;
  693. }
  695. volume->updateRelativeXform();
  696. doFlexibleUpdate();
  698. // Object may have been rotated, which means it needs a rebuild.  See SL-47220
  699. BOOL rotated = FALSE;
  700. LLQuaternion cur_rotation = getFrameRotation();
  701. if ( cur_rotation != mLastFrameRotation )
  702. {
  703. mLastFrameRotation = cur_rotation;
  704. rotated = TRUE;
  705. }
  707. if (volume->mLODChanged || volume->mFaceMappingChanged ||
  708. volume->mVolumeChanged || drawable->isState(LLDrawable::REBUILD_MATERIAL))
  709. {
  710. volume->regenFaces();
  711. volume->mDrawable->setState(LLDrawable::REBUILD_VOLUME);
  712. volume->dirtySpatialGroup();
  713. doFlexibleRebuild();
  714. volume->genBBoxes(isVolumeGlobal());
  715. }
  716. else if (!mUpdated || rotated)
  717. {
  718. volume->mDrawable->setState(LLDrawable::REBUILD_POSITION);
  719. volume->dirtyMesh();
  720. volume->genBBoxes(isVolumeGlobal());
  721. }
  723. volume->mVolumeChanged = FALSE;
  724. volume->mLODChanged = FALSE;
  725. volume->mFaceMappingChanged = FALSE;
  727. // clear UV flag
  728. drawable->clearState(LLDrawable::UV);
  730. return TRUE;
  731. }
  733. //----------------------------------------------------------------------------------
  734. void LLVolumeImplFlexible::setCollisionSphere( LLVector3 p, F32 r )
  735. {
  736. mCollisionSpherePosition = p;
  737. mCollisionSphereRadius   = r;
  739. }//------------------------------------------------------------------
  742. //----------------------------------------------------------------------------------
  743. void LLVolumeImplFlexible::setUsingCollisionSphere( bool u )
  744. {
  745. }//------------------------------------------------------------------
  748. //----------------------------------------------------------------------------------
  749. void LLVolumeImplFlexible::setRenderingCollisionSphere( bool r )
  750. {
  751. }//------------------------------------------------------------------
  753. //------------------------------------------------------------------
  754. LLVector3 LLVolumeImplFlexible::getEndPosition()
  755. {
  756. S32 num_sections = 1 << mAttributes->getSimulateLOD();
  757. return mSection[ num_sections ].mPosition;
  759. }//------------------------------------------------------------------
  762. //------------------------------------------------------------------
  763. LLVector3 LLVolumeImplFlexible::getNodePosition( int nodeIndex )
  764. {
  765. S32 num_sections = 1 << mAttributes->getSimulateLOD();
  766. if ( nodeIndex > num_sections - 1 )
  767. {
  768. nodeIndex = num_sections - 1;
  769. }
  770. else if ( nodeIndex < 0 ) 
  771. {
  772. nodeIndex = 0;
  773. }
  775. return mSection[ nodeIndex ].mPosition;
  777. }//------------------------------------------------------------------
  779. LLVector3 LLVolumeImplFlexible::getPivotPosition() const
  780. {
  781. return getAnchorPosition();
  782. }
  784. //------------------------------------------------------------------
  785. LLVector3 LLVolumeImplFlexible::getAnchorPosition() const
  786. {
  787. LLVector3 BasePosition = getFramePosition();
  788. LLQuaternion parentSegmentRotation = getFrameRotation();
  789. LLVector3 anchorDirectionRotated = LLVector3::z_axis * parentSegmentRotation;
  790. LLVector3 anchorScale = mVO->mDrawable->getScale();
  791. return BasePosition - (anchorScale.mV[VZ]/2 * anchorDirectionRotated);
  793. }//------------------------------------------------------------------
  796. //------------------------------------------------------------------
  797. LLQuaternion LLVolumeImplFlexible::getEndRotation()
  798. {
  799. return mLastSegmentRotation;
  801. }//------------------------------------------------------------------
  804. void LLVolumeImplFlexible::updateRelativeXform()
  805. {
  806. LLQuaternion delta_rot;
  807. LLVector3 delta_pos, delta_scale;
  808. LLVOVolume* vo = (LLVOVolume*) mVO;
  810. //matrix from local space to parent relative/global space
  811. delta_rot = vo->mDrawable->isSpatialRoot() ? LLQuaternion() : vo->mDrawable->getRotation();
  812. delta_pos = vo->mDrawable->isSpatialRoot() ? LLVector3(0,0,0) : vo->mDrawable->getPosition();
  813. delta_scale = LLVector3(1,1,1);
  815. // Vertex transform (4x4)
  816. LLVector3 x_axis = LLVector3(delta_scale.mV[VX], 0.f, 0.f) * delta_rot;
  817. LLVector3 y_axis = LLVector3(0.f, delta_scale.mV[VY], 0.f) * delta_rot;
  818. LLVector3 z_axis = LLVector3(0.f, 0.f, delta_scale.mV[VZ]) * delta_rot;
  820. vo->mRelativeXform.initRows(LLVector4(x_axis, 0.f),
  821. LLVector4(y_axis, 0.f),
  822. LLVector4(z_axis, 0.f),
  823. LLVector4(delta_pos, 1.f));
  825. x_axis.normVec();
  826. y_axis.normVec();
  827. z_axis.normVec();
  829. vo->mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
  830. }
  832. const LLMatrix4& LLVolumeImplFlexible::getWorldMatrix(LLXformMatrix* xform) const
  833. {
  834. return xform->getWorldMatrix();
  835. }