BVB Source Codes

CRYENGINE Show AttachmentPRow.cpp Source code

Return Download CRYENGINE: download AttachmentPRow.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "stdafx.h"
  4. #include "AttachmentPRow.h"
  5.  
  6. #include <CryString/StringUtils.h>
  7. #include "AttachmentManager.h"
  8. #include "CharacterInstance.h"
  9.  
  10. void CAttachmentPROW::UpdateRow(Skeleton::CPoseData& rPoseData)
  11. {
  12.         if (m_nRowJointID < 0)
  13.                 return;
  14.         if (m_rowparams.m_nParticlesPerRow == 0)
  15.                 return;
  16.  
  17.         const CCharInstance* pSkelInstance = m_pAttachmentManager->m_pSkelInstance;
  18.         const CDefaultSkeleton& rDefaultSkeleton = *pSkelInstance->m_pDefaultSkeleton;
  19.  
  20. #ifdef EDITOR_PCDEBUGCODE
  21.         //ERROR-CHECK: check if bones and x-axis align
  22.         if (pSkelInstance->m_CharEditMode & CA_CharacterTool)
  23.         {
  24.                 QuatTS rPhysLocation = pSkelInstance->m_location;
  25.                 g_pAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def3DPublicRenderflags));
  26.                 for (uint32 i = 0; i < m_rowparams.m_nParticlesPerRow; i++)
  27.                 {
  28.                         if (m_rowparams.m_arrParticles[i].m_childID != JointIdType(-1))
  29.                         {
  30.                                 JointIdType jid = m_rowparams.m_arrParticles[i].m_jointID;
  31.                                 JointIdType cid = m_rowparams.m_arrParticles[i].m_childID;
  32.  
  33.                                 Vec3 xaxis = rDefaultSkeleton.GetDefaultAbsJointByID(jid).q.GetColumn0();
  34.  
  35.                                 const char* pname = rDefaultSkeleton.GetJointNameByID(jid);
  36.                                 const Vec3& j0 = rDefaultSkeleton.GetDefaultAbsJointByID(jid).t;
  37.                                 const Vec3& j1 = rDefaultSkeleton.GetDefaultAbsJointByID(cid).t;
  38.                                 const f32 jointlen = (j1 - j0).GetLength();
  39.                                 Vec3 naxis = (j1 - j0).GetNormalized();
  40.                                 f32 dist = (naxis - xaxis).GetLength();
  41.                                 if (dist > 0.0001f)
  42.                                 {
  43.                                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 2.3f, ColorF(1, 0, 0, 1), false, "Joint '%s' not aligned with X-Axis", pname), g_YLine += 26.0f;
  44.                                         g_pAuxGeom->DrawLine(rPhysLocation * j0, RGBA8(0x00, 0xff, 0x00, 0x00), rPhysLocation * j1, RGBA8(0x00, 0xff, 0x00, 0x00));
  45.                                         g_pAuxGeom->DrawLine(rPhysLocation * j0, RGBA8(0xff, 0x00, 0x00, 0x00), rPhysLocation * (j0 + xaxis * jointlen), RGBA8(0xff, 0x0, 0x00, 0x00));
  46.                                 }
  47.                         }
  48.                 }
  49.         }
  50. #endif
  51.  
  52.         JointState* pJointState = rPoseData.GetJointsStatus();
  53.         for (uint32 i = 0; i < m_rowparams.m_nParticlesPerRow; i++)
  54.         {
  55.                 Particle& dm = m_rowparams.m_arrParticles[i];
  56.                 if ((pJointState[dm.m_jointID] & (eJS_Orientation | eJS_Position)) != (eJS_Orientation | eJS_Position))
  57.                 {
  58.                         const uint32 pid = rDefaultSkeleton.GetJointParentIDByID(dm.m_jointID);
  59.                         rPoseData.SetJointRelative(dm.m_jointID, rDefaultSkeleton.GetDefaultRelJointByID(dm.m_jointID));
  60.                         rPoseData.SetJointAbsolute(dm.m_jointID, rPoseData.GetJointAbsolute(pid) * rDefaultSkeleton.GetDefaultRelJointByID(dm.m_jointID));
  61.                         pJointState[dm.m_jointID] = eJS_Orientation | eJS_Position;
  62.                 }
  63.         }
  64.         m_rowparams.UpdatePendulumRow(m_pAttachmentManager, rPoseData, GetName());
  65. };
  66.  
  67. const QuatTS CAttachmentPROW::GetAttWorldAbsolute() const
  68. {
  69.         QuatTS rPhysLocation = m_pAttachmentManager->m_pSkelInstance->m_location;
  70.         return rPhysLocation;
  71. };
  72.  
  73. uint32 CAttachmentPROW::SetJointName(const char* szJointName)
  74. {
  75.         m_nRowJointID = -1;
  76.         if (!szJointName)  { assert(0); return 0; }
  77.         int nJointID = m_pAttachmentManager->m_pSkelInstance->m_pDefaultSkeleton->GetJointIDByName(szJointName);
  78.         if (nJointID < 0)
  79.         {
  80.                 // this is a severe bug if the bone name is invalid and someone tries to attach something
  81.                 g_pILog->LogError("AttachObjectToJoint is called for bone \"%s\", which is not in the model \"%s\". Ignoring, but this may cause a crash because the corresponding object won't be detached after it's destroyed", szJointName, m_pAttachmentManager->m_pSkelInstance->m_pDefaultSkeleton->GetModelFilePath());
  82.                 return 0;
  83.         }
  84.         m_strRowJointName = szJointName;
  85.         m_nRowJointID = nJointID;
  86.         m_pAttachmentManager->m_TypeSortingRequired++;
  87.         return 1;
  88. };
  89.  
  90. void CAttachmentPROW::PostUpdateSimulationParams(bool bAttachmentSortingRequired, const char* pJointName)
  91. {
  92.         m_pAttachmentManager->m_TypeSortingRequired += bAttachmentSortingRequired;
  93.         m_rowparams.PostUpdate(m_pAttachmentManager, 0);
  94. };
  95.  
  96. void CAttachmentPROW::HideInRecursion(uint32 x)
  97. {
  98.         m_pAttachmentManager->OnHideAttachment(this, FLAGS_ATTACH_HIDE_RECURSION, x != 0);
  99.  
  100.         if (x)
  101.                 m_AttFlags |= FLAGS_ATTACH_HIDE_RECURSION;
  102.         else
  103.                 m_AttFlags &= ~FLAGS_ATTACH_HIDE_RECURSION;
  104. }
  105.  
  106. void CAttachmentPROW::HideInShadow(uint32 x)
  107. {
  108.         m_pAttachmentManager->OnHideAttachment(this, FLAGS_ATTACH_HIDE_SHADOW_PASS, x != 0);
  109.  
  110.         if (x)
  111.                 m_AttFlags |= FLAGS_ATTACH_HIDE_SHADOW_PASS;
  112.         else
  113.                 m_AttFlags &= ~FLAGS_ATTACH_HIDE_SHADOW_PASS;
  114. }
  115.  
  116. void CPendulaRow::PostUpdate(const CAttachmentManager* pAttachmentManager, const char* pJointName)
  117. {
  118.         const CCharInstance* pSkelInstance = pAttachmentManager->m_pSkelInstance;
  119.         const CDefaultSkeleton& rDefaultSkeleton = *pSkelInstance->m_pDefaultSkeleton;
  120.  
  121.         m_fConeAngle = max(0.00f, m_fConeAngle);
  122.  
  123.         m_nSimFPS = m_nSimFPS < 10 ? 10 : m_nSimFPS;
  124.         m_fMaxAngleCos = clamp_tpl(DEG2COS(max(0.01f, m_fConeAngle)), -1.0f, 1.0f);
  125.         m_fMaxAngleHCos = clamp_tpl(DEG2HCOS(max(0.01f, m_fConeAngle)), 0.0f, 1.0f);
  126.  
  127.         m_vConeRotHCos.x = clamp_tpl(DEG2HCOS(m_vConeRotation.x), -1.0f, 1.0f);
  128.         m_vConeRotHSin.x = clamp_tpl(DEG2HSIN(m_vConeRotation.x), -1.0f, 1.0f);
  129.  
  130.         m_vConeRotHCos.y = clamp_tpl(DEG2HCOS(m_vConeRotation.y), -1.0f, 1.0f);
  131.         m_vConeRotHSin.y = clamp_tpl(DEG2HSIN(m_vConeRotation.y), -1.0f, 1.0f);
  132.  
  133.         m_vConeRotHCos.z = clamp_tpl(DEG2HCOS(m_vConeRotation.z), -1.0f, 1.0f);
  134.         m_vConeRotHSin.z = clamp_tpl(DEG2HSIN(m_vConeRotation.z), -1.0f, 1.0f);
  135.  
  136.         m_pitchc = clamp_tpl(DEG2HCOS(m_vStiffnessTarget.x), -1.0f, 1.0f);
  137.         m_pitchs = clamp_tpl(DEG2HSIN(m_vStiffnessTarget.x), -1.0f, 1.0f);
  138.  
  139.         m_rollc = clamp_tpl(DEG2HCOS(m_vStiffnessTarget.y), -1.0f, 1.0f);
  140.         m_rolls = clamp_tpl(DEG2HSIN(m_vStiffnessTarget.y), -1.0f, 1.0f);
  141.  
  142.         m_fMass = max(0.01f, m_fMass);
  143.         m_vCapsule.x = clamp_tpl(max(0.0f, m_vCapsule.x), 0.0f, 5.0f);
  144.         m_vCapsule.y = clamp_tpl(max(0.0f, m_vCapsule.y), 0.0f, 5.0f);
  145.  
  146.         m_arrProxyIndex.resize(0);
  147.         uint32 numUsedProxies = m_arrProxyNames.size();
  148.         uint32 numAllProxies = pAttachmentManager->m_arrProxies.size();
  149.         for (uint32 i = 0; i < numUsedProxies; i++)
  150.         {
  151.                 uint32 nCRC32lower = CCrc32::ComputeLowercase(m_arrProxyNames[i].c_str());
  152.                 for (uint32 p = 0; p < numAllProxies; p++)
  153.                 {
  154.                         if (nCRC32lower == pAttachmentManager->m_arrProxies[p].m_nProxyCRC32)
  155.                         {
  156.                                 m_arrProxyIndex.push_back(p);
  157.                                 break;
  158.                         }
  159.                 }
  160.         }
  161. }
  162.  
  163. void CPendulaRow::UpdatePendulumRow(const CAttachmentManager* pAttachmentManager, Skeleton::CPoseData& rPoseData, const char* pAttName)
  164. {
  165.         const CCharInstance* pSkelInstance = pAttachmentManager->m_pSkelInstance;
  166.         const CDefaultSkeleton& rDefaultSkeleton = *pSkelInstance->m_pDefaultSkeleton;
  167.         QuatTS rPhysLocation = pSkelInstance->m_location;
  168.         const uint32 nBindPose = pSkelInstance->m_CharEditMode & (CA_BindPose | CA_AllowRedirection);
  169.         if (m_nClampMode == RowSimulationParams::TRANSLATIONAL_PROJECTION)
  170.         {
  171.                 bool allowTranslation = nBindPose == 0 && m_useSimulation;
  172.                 const uint32 numProxies = allowTranslation && m_nProjectionType && (m_vCapsule.x + m_vCapsule.y) ? m_arrProxyIndex.size() : 0;
  173.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  174.                 {
  175.                         Particle& dm = m_arrParticles[i];
  176.                         const QuatT absJoint = rPoseData.GetJointAbsolute(dm.m_jointID);
  177.                         Vec3 axis = absJoint.q * m_vTranslationAxis;
  178.                         if (numProxies && m_nProjectionType == 2 && m_idxDirTransJoint > -1)
  179.                                 axis = (rPoseData.GetJointAbsolute(m_idxDirTransJoint).t - absJoint.t).GetNormalized();
  180.                         Vec3 trans = absJoint.t;
  181.                         for (uint32 x = 0; x < numProxies; x++)
  182.                         {
  183.                                 const CProxy& proxy = pAttachmentManager->m_arrProxies[m_arrProxyIndex[x]];
  184.                                 Vec3 ipos = (trans - proxy.m_ProxyModelRelative.t) * proxy.m_ProxyModelRelative.q;
  185.                                 if (m_nProjectionType == 1) //shortvec projections: this one works only with a sphere (the head of the capsule)
  186.                                         trans += proxy.m_ProxyModelRelative.q * proxy.ShortvecTranslationalProjection(ipos, m_vCapsule.y);
  187.                                 if (m_nProjectionType == 2)
  188.                                         trans -= axis * proxy.DirectedTranslationalProjection(ipos, axis * proxy.m_ProxyModelRelative.q, m_vCapsule.x, m_vCapsule.y);
  189.                         }
  190.                         Vec3 trans_delta = trans - absJoint.t;
  191.                         if (trans_delta | trans_delta)
  192.                         {
  193.                                 QuatT& absjoint = (QuatT&)rPoseData.GetJointAbsolute(dm.m_jointID);
  194.                                 absjoint.t += trans_delta;
  195.                                 const uint32 p = rDefaultSkeleton.GetJointParentIDByID(dm.m_jointID);
  196.                                 rPoseData.SetJointRelative(dm.m_jointID, rPoseData.GetJointAbsolute(p).GetInverted() * absjoint);
  197.                                 if (dm.m_childID != JointIdType(-1))
  198.                                 {
  199.                                         const uint32 id = dm.m_childID;
  200.                                         const uint32 pid = rDefaultSkeleton.GetJointParentIDByID(id);
  201.                                         rPoseData.SetJointAbsolute(id, rPoseData.GetJointAbsolute(pid) * rPoseData.GetJointRelative(id));
  202.                                 }
  203.                         }
  204.  
  205.                         //--------------------------------------------------------------------------------------------------------------
  206.  
  207. #ifdef EDITOR_PCDEBUGCODE
  208.                         uint32 nDrawDynamicProxies = ((m_vCapsule.x + m_vCapsule.y) && (pAttachmentManager->m_nDrawProxies & 1));
  209.                         if (nDrawDynamicProxies || m_useDebugSetup || Console::GetInst().ca_DrawAllSimulatedSockets)
  210.                         {
  211.                                 Vec3 delta = trans - absJoint.t;
  212.                                 const QuatTS AttLocation = rPhysLocation * absJoint;
  213.                                 QuatT raddTransformation = QuatT(IDENTITY, delta * absJoint.q);
  214.                                 QuatTS AttWorldAbsolute = rPhysLocation * absJoint * raddTransformation;
  215.                                 g_pAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def3DPublicRenderflags));
  216.                                 axis = rPhysLocation.q * axis;
  217.                                 uint32 nValidDirTrans = m_nProjectionType == 2 && m_idxDirTransJoint > -1;
  218.                                 if (nValidDirTrans)
  219.                                 {
  220.                                         Vec3 pos = rPhysLocation * rPoseData.GetJointAbsolute(m_idxDirTransJoint).t;
  221.                                         g_pAuxGeom->DrawLine(pos, RGBA8(0xff, 0xff, 0xff, 0xff), AttLocation.t, RGBA8(0x7f, 0x00, 0x00, 0xff));
  222.                                         g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0x7f, 0x00, 0x00, 0xff), (AttLocation.t - axis * 0.15f), RGBA8(0xff, 0x00, 0x00, 0xff));
  223.                                 }
  224.                                 QuatTS cloc(Quat::CreateRotationV0V1(Vec3(1, 0, 0), axis), axis * m_vCapsule.x + AttWorldAbsolute.t, AttWorldAbsolute.s);
  225.                                 f32 outprojection = sqr(delta);
  226.                                 Draw(cloc, outprojection ? RGBA8(0x67, 0xf0, 0xac, 0xff) : RGBA8(0x67, 0xa0, 0xbc, 0xff), 4, pSkelInstance->m_Viewdir);
  227.                                 if (outprojection)
  228.                                 {
  229.                                         Vec3 ndir = rPhysLocation.q * delta.GetNormalized();
  230.                                         f32 tanslation = delta.GetLength() + m_vCapsule.y;
  231.                                         g_pAuxGeom->DrawLine(AttWorldAbsolute.t, RGBA8(0x00, 0xff, 0x00, 0xff), ndir * tanslation + AttWorldAbsolute.t, RGBA8(0x00, 0xff, 0x00, 0xff));
  232.                                 }
  233.                         }
  234. #endif
  235.                 }
  236.                 return;
  237.         }
  238.  
  239. #ifdef EDITOR_PCDEBUGCODE
  240.         QuatT remJointLocation[MAX_JOINT_AMOUNT];
  241.         for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  242.         {
  243.                 Particle& dm = m_arrParticles[i];
  244.                 remJointLocation[i] = rPoseData.GetJointAbsolute(dm.m_jointID);
  245.         }
  246. #endif
  247.  
  248.         bool allowSimulation = nBindPose == 0 && m_fConeAngle && m_useSimulation;
  249.         if (allowSimulation == 0)
  250.         {
  251.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  252.                 {
  253.                         Particle& dm = m_arrParticles[i];
  254.                         dm.m_vBobVelocity.zero();
  255.                         dm.m_vBobPosition = (rPhysLocation * rPoseData.GetJointAbsolute(dm.m_jointID)) * Vec3(m_fRodLength, 0.0f, 0.0f);
  256.                 }
  257.         }
  258.  
  259.         const f32 fIPlaybackScale = pSkelInstance->GetPlaybackScale();
  260.         const f32 fLPlaybackScale = pSkelInstance->m_SkeletonAnim.GetLayerPlaybackScale(0);
  261.         const f32 fAverageFrameTime = g_AverageFrameTime * fIPlaybackScale * fLPlaybackScale ? g_AverageFrameTime * fIPlaybackScale * fLPlaybackScale : g_AverageFrameTime;
  262.         const f32 fPhysFramerate = 1.0f / f32(m_nSimFPS);
  263.         const f32 dt = fAverageFrameTime > fPhysFramerate ? fAverageFrameTime : fPhysFramerate;
  264.         m_fTimeAccumulator += fAverageFrameTime;
  265.  
  266.         const f32 fMaxAngleHSin = sqrt_tpl(fabs(1.0f - m_fMaxAngleHCos * m_fMaxAngleHCos));
  267.         const f32 fInvMass = 1.0f / m_fMass;
  268.  
  269.         const Quat qx = Quat(m_vConeRotHCos.x, Vec3(m_vConeRotHSin.x, 0, 0));
  270.         const Quat qyz = Quat(m_vConeRotHCos.y, Vec3(0, m_vConeRotHSin.y, 0)) * Quat(m_vConeRotHCos.z, Vec3(0, 0, m_vConeRotHSin.z));
  271.  
  272.         f32 speed = pSkelInstance->m_SkeletonAnim.GetCurrentVelocity().GetLength() / 6.0f;
  273.         speed = min(1.0f, speed);
  274.         f32 t0 = 1.0f - speed;
  275.         f32 t1 = speed;
  276.  
  277. #ifdef EDITOR_PCDEBUGCODE
  278.         if (m_useDebugText)
  279.                 if (dt) g_YLine += 8.0f, g_pAuxGeom->Draw2dLabel(1, g_YLine, 1.3f, ColorF(0, 1, 0, 1), false, "dt: %f  fRealFPS: %f    fSimFPS: %f  fStiffness: %f  m_fMaxAngle: %f m_fGravity: %f", dt, 1.0f / dt, f32(m_nSimFPS), m_fJointSpring, m_fConeAngle, m_fGravity), g_YLine += 16.0f;
  280. #endif
  281.  
  282.         uint16 arrSetupError[MAX_JOINTS_PER_ROW];
  283.         memset(arrSetupError, 0, m_nParticlesPerRow * sizeof(uint16));
  284.  
  285.         Vec3 arrPrevBobPositions[MAX_JOINTS_PER_ROW];
  286.         f32 arrDamping[MAX_JOINTS_PER_ROW];
  287.         if (allowSimulation)
  288.         {
  289.                 const uint32 numProxies = m_nProjectionType && (m_vCapsule.x + m_vCapsule.y) ? m_arrProxyIndex.size() : 0;
  290.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  291.                 {
  292.                         Particle& dm = m_arrParticles[i];
  293.                         arrPrevBobPositions[i] = dm.m_vBobPosition;
  294.                         arrDamping[i] = m_fDamping;
  295.  
  296.                         const QuatT absJoint = rPoseData.GetJointAbsolute(dm.m_jointID) * qyz;
  297.                         const QuatTS AttLocation = rPhysLocation * absJoint;
  298.  
  299.                         (f32&)pAttachmentManager->m_fTurbulenceLocal += m_vTurbulence.x;
  300.                         f32 val = pAttachmentManager->m_fTurbulenceGlobal + pAttachmentManager->m_fTurbulenceLocal;
  301.                         f32 noise = sin_tpl(val) * m_fDamping * m_vTurbulence.y;
  302.                         arrDamping[i] = max(0.0f, m_fDamping * t0 + (m_fDamping + noise) * t1);
  303.  
  304.                         //---------------------------------------------------------------------------------
  305.  
  306.                         const f32 t = 1;
  307.                         const QuatT AttLocationLerp = QuatT::CreateNLerp(dm.m_vLocationPrev, QuatT(AttLocation.q, AttLocation.t), t);
  308.                         const Vec3 hn = (AttLocationLerp.q * qx).GetColumn2();
  309.                         const Vec3 vRodDefN = AttLocationLerp.q.GetColumn0(); //this is the Cone-Axis
  310.                         const Vec3 vStiffnessTarget = Quat(m_rollc, m_rolls * vRodDefN) * Quat(m_pitchc, m_pitchs * hn) * vRodDefN;
  311.  
  312.                         if (m_fTimeAccumulator >= fPhysFramerate)
  313.                         {
  314.                                 const Vec3 vAcceleration = vStiffnessTarget * m_fJointSpring * fInvMass - dm.m_vBobVelocity * arrDamping[i] - Vec3(0, 0, m_fGravity);
  315.                                 dm.m_vBobVelocity += vAcceleration * dt * 0.5f; //Integrating the acceleration over time gives the velocity
  316.                                 dm.m_vBobPosition += dm.m_vBobVelocity * dt;    //Integrating the acceleration twice over time gives the position.
  317.                         }
  318.  
  319.                         Vec3 vRodAnim = dm.m_vBobPosition - AttLocationLerp.t, a; //translate pendulum-position into local space
  320.                         if (m_nClampMode == RowSimulationParams::PENDULUM_HINGE_PLANE)
  321.                                 vRodAnim -= hn * (hn | vRodAnim);
  322.                         if (m_nClampMode == RowSimulationParams::PENDULUM_HALF_CONE)
  323.                                 vRodAnim -= hn * ((hn | vRodAnim) > 0.0f ? hn | vRodAnim : 0);
  324.  
  325.                         for (uint32 x = 0; x < numProxies; x++)
  326.                         {
  327.                                 vRodAnim *= isqrt_tpl(vRodAnim | vRodAnim);
  328.                                 if (sqrt_tpl(fabs_tpl((vRodDefN | vRodAnim) * 0.5f + 0.5f)) < m_fMaxAngleHCos)
  329.                                         a = vRodDefN % vRodAnim, vRodAnim = Quat(m_fMaxAngleHCos, a * isqrt_tpl(a | a) * fMaxAngleHSin) * vRodDefN;
  330.                                 const CProxy& proxy = pAttachmentManager->m_arrProxies[m_arrProxyIndex[x]];
  331.                                 const QuatT absProxyPrev = rPhysLocation.q * proxy.m_ProxyModelRelativePrev;
  332.                                 const QuatT absProxyCurr = rPhysLocation.q * proxy.m_ProxyModelRelative;
  333.                                 const QuatT absProxyLerp = QuatT::CreateNLerp(absProxyPrev, absProxyCurr, t);
  334.                                 const Vec3 ipos = (Vec3::CreateLerp(dm.m_vAttModelRelativePrev, rPhysLocation.q * absJoint.t, t) - absProxyLerp.t) * absProxyLerp.q;
  335.                                 if (proxy.GetDistance(ipos, m_vCapsule.y) < 0.0007f)
  336.                                 {
  337. #ifdef EDITOR_PCDEBUGCODE
  338.                                         if (pSkelInstance->GetCharEditMode())
  339.                                         {
  340.                                                 f32 dist = proxy.GetDistance(ipos, m_vCapsule.y);
  341.                                                 g_pAuxGeom->Draw2dLabel(1, g_YLine, 1.3f, ColorF(1, 0, 0, 1), false, "Capsule for '%s' starts inside of proxy: %s (dist: %f)", pAttName, proxy.GetName(), dist), g_YLine += 16.0f;
  342.                                                 arrSetupError[i]++;
  343.                                         }
  344. #endif
  345.                                         continue;
  346.                                 }
  347.  
  348.                                 const Vec3 idir = (vRodAnim * absProxyLerp.q).GetNormalized();
  349.                                 if (proxy.TestOverlapping(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y) >= -0.0000001)
  350.                                         continue;
  351.  
  352.                                 if (m_nProjectionType == 2 && m_nClampMode == RowSimulationParams::PENDULUM_HINGE_PLANE)
  353.                                         vRodAnim = absProxyLerp.q * proxy.DirectedRotationalProjection(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y, -(hn * absProxyLerp.q).GetNormalized());
  354.                                 else
  355.                                         vRodAnim = absProxyLerp.q * proxy.ShortarcRotationalProjection(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y);
  356.                         }
  357.  
  358.                         vRodAnim *= isqrt_tpl(vRodAnim | vRodAnim);
  359.                         if ((vRodDefN | vRodAnim) < m_fMaxAngleCos)
  360.                                 a = vRodDefN % vRodAnim, vRodAnim = Quat(m_fMaxAngleHCos, a * isqrt_tpl(a | a) * fMaxAngleHSin) * vRodDefN;
  361.                         dm.m_vBobPosition = vRodAnim * m_fRodLength + AttLocationLerp.t; //set correct initial position for next frame
  362.                 }                                                                  //for loop
  363.  
  364.                 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------
  365.  
  366.                 Vec3 arrLinks[MAX_JOINTS_PER_ROW];
  367.                 Vec3 arrParticles[MAX_JOINTS_PER_ROW];
  368.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  369.                 {
  370.                         Particle& dm = m_arrParticles[i];
  371.                         const Vec3& jointpos = rPoseData.GetJointAbsolute(dm.m_jointID).t;
  372.                         arrLinks[i] = rPhysLocation * jointpos;
  373.                 }
  374.  
  375.                 uint32 relaxLinks = m_nParticlesPerRow - !m_cycle;
  376.                 for (uint32 c = 0; c < m_relaxationLoops; c++)
  377.                 {
  378.                         for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  379.                         {
  380.                                 Particle& dm = m_arrParticles[i];
  381.                                 Vec3 naxis = (dm.m_vBobPosition - arrLinks[i]).GetNormalized();
  382.                                 arrParticles[i] = naxis * dm.m_vDistance.y + arrLinks[i];
  383.                         }
  384.  
  385.                         for (uint32 i0 = 0; i0 < relaxLinks; i0++)
  386.                         {
  387.                                 Particle& dm = m_arrParticles[i0];
  388.                                 const f32 max_stretch = dm.m_vDistance.x * (1.0f + m_fStretch);
  389.                                 const f32 min_stretch = dm.m_vDistance.x * (1.0f - m_fStretch);
  390.                                 uint32 i1 = (i0 + 1) % m_nParticlesPerRow;
  391.                                 Vec3& p0 = arrParticles[i0];
  392.                                 Vec3& p1 = arrParticles[i1];
  393.                                 Vec3 distance = p0 - p1, d, m;
  394.                                 f32 sqlen = distance | distance;
  395.                                 if (sqlen == 0)
  396.                                         continue;
  397.                                 f32 isqrt = 1.0f / sqrt_tpl(sqlen) * 0.5f;
  398.                                 distance.x *= isqrt;
  399.                                 distance.y *= isqrt;
  400.                                 distance.z *= isqrt;
  401.                                 if (sqlen > max_stretch * max_stretch)
  402.                                         d = distance * max_stretch, m = (p0 + p1) * 0.5f, p0 = m + d, p1 = m - d;
  403.                                 if (sqlen < min_stretch * min_stretch)
  404.                                         d = distance * min_stretch, m = (p0 + p1) * 0.5f, p0 = m + d, p1 = m - d;
  405.                         }
  406.  
  407.                         for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  408.                         {
  409.                                 Particle& dm = m_arrParticles[i];
  410.  
  411.                                 Vec3 s0 = arrLinks[i];
  412.                                 Vec3 p0 = arrParticles[i];
  413.                                 dm.m_vBobPosition = s0 + (p0 - s0).GetNormalized() * m_fRodLength;
  414.                                 const QuatT absJoint = rPoseData.GetJointAbsolute(dm.m_jointID) * qyz;
  415.                                 const QuatTS AttLocation = rPhysLocation * absJoint;
  416.  
  417.                                 const Vec3 op = dm.m_vBobPosition;
  418.                                 f32 t = 1;
  419.                                 const QuatT AttLocationLerp = QuatT::CreateNLerp(dm.m_vLocationPrev, QuatT(AttLocation.q, AttLocation.t), t);
  420.                                 const Vec3 hn = (AttLocationLerp.q * qx).GetColumn2();
  421.                                 const Vec3 vRodDefN = AttLocationLerp.q.GetColumn0();
  422.  
  423.                                 Vec3 vRodAnim = dm.m_vBobPosition - AttLocationLerp.t, a; //translate pendulum-position into local space
  424.                                 if (m_nClampMode == RowSimulationParams::PENDULUM_HINGE_PLANE)
  425.                                         vRodAnim -= hn * (hn | vRodAnim);
  426.                                 if (m_nClampMode == RowSimulationParams::PENDULUM_HALF_CONE)
  427.                                         vRodAnim -= hn * ((hn | vRodAnim) > 0.0f ? hn | vRodAnim : 0);
  428.  
  429.                                 for (uint32 x = 0; x < numProxies; x++)
  430.                                 {
  431.                                         vRodAnim *= isqrt_tpl(vRodAnim | vRodAnim);
  432.                                         if (sqrt_tpl(fabs_tpl((vRodDefN | vRodAnim) * 0.5f + 0.5f)) < m_fMaxAngleHCos)
  433.                                                 a = vRodDefN % vRodAnim, vRodAnim = Quat(m_fMaxAngleHCos, a * isqrt_tpl(a | a) * fMaxAngleHSin) * vRodDefN;
  434.                                         const CProxy& proxy = pAttachmentManager->m_arrProxies[m_arrProxyIndex[x]];
  435.                                         const QuatT absProxyPrev = rPhysLocation.q * proxy.m_ProxyModelRelativePrev;
  436.                                         const QuatT absProxyCurr = rPhysLocation.q * proxy.m_ProxyModelRelative;
  437.                                         const QuatT absProxyLerp = QuatT::CreateNLerp(absProxyPrev, absProxyCurr, t);
  438.                                         const Vec3 ipos = (Vec3::CreateLerp(dm.m_vAttModelRelativePrev, rPhysLocation.q * absJoint.t, t) - absProxyLerp.t) * absProxyLerp.q;
  439.                                         if (proxy.GetDistance(ipos, m_vCapsule.y) < 0.001f)
  440.                                         {
  441.                                                 f32 dist = proxy.GetDistance(ipos, m_vCapsule.y);
  442.                                                 //g_pAuxGeom->Draw2dLabel( 1, g_YLine, 1.3f, ColorF(0,1,0,1), false,"Capsule for '%s' starts inside of proxy: %s (dist: %f)",pAttName,proxy.GetName(),dist), g_YLine+=16.0f;
  443.                                                 continue;
  444.                                         }
  445.                                         const Vec3 idir = (vRodAnim * absProxyLerp.q).GetNormalized();
  446.                                         if (proxy.TestOverlapping(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y) >= -0.0000001)
  447.                                                 continue;
  448.                                         if (m_nClampMode == RowSimulationParams::PENDULUM_HINGE_PLANE)
  449.                                                 vRodAnim = absProxyLerp.q * proxy.DirectedRotationalProjection(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y, -(hn * absProxyLerp.q).GetNormalized());
  450.                                         else
  451.                                                 vRodAnim = absProxyLerp.q * proxy.ShortarcRotationalProjection(ipos, idir, m_vCapsule.x * 2, m_vCapsule.y);
  452.                                 }
  453.  
  454.                                 vRodAnim *= isqrt_tpl(vRodAnim | vRodAnim);
  455.                                 if ((vRodDefN | vRodAnim) < m_fMaxAngleCos)
  456.                                         a = vRodDefN % vRodAnim, vRodAnim = Quat(m_fMaxAngleHCos, a * isqrt_tpl(a | a) * fMaxAngleHSin) * vRodDefN;
  457.                                 dm.m_vBobPosition = vRodAnim * m_fRodLength + AttLocationLerp.t; //set correct initial position for next frame
  458.  
  459.                         }
  460.                 } //amount of relaxation loops
  461.  
  462.                 //--------------------------------------------------------------------
  463.                 //----                apply to skeleton only once      ---------------
  464.                 //--------------------------------------------------------------------
  465.                 const uint32 nAllowRedirect = nBindPose & CA_BindPose ? nBindPose & CA_AllowRedirection : 1;
  466.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  467.                 {
  468.                         Particle& dm = m_arrParticles[i];
  469.                         const QuatT absJoint = rPoseData.GetJointAbsolute(dm.m_jointID) * qyz;
  470.                         const QuatTS AttLocation = rPhysLocation * absJoint;
  471.  
  472.                         //add the simulation-quat to the relative AttModelRelative
  473.                         const Vec3 vRodAnimN = (dm.m_vBobPosition - AttLocation.t) * isqrt_tpl(sqr(dm.m_vBobPosition - AttLocation.t));
  474.                         const Vec3 hn = (AttLocation.q * qx).GetColumn2();
  475.                         const Vec3 vRodDefN = AttLocation.q.GetColumn0(); //this is the Cone-Axis
  476.                         const Quat R = Quat((vRodDefN | vRodAnimN) + 1.0f, vRodDefN % vRodAnimN).GetNormalized();
  477.                         const f32 t = m_nAnimOverrideJoint > 0 ? 1 - rPoseData.GetJointAbsolute(m_nAnimOverrideJoint).t.x : 1;
  478.                         if (m_fTimeAccumulator >= fPhysFramerate)
  479.                         {
  480.                                 const QuatT AttLocationLerp = QuatT::CreateNLerp(dm.m_vLocationPrev, QuatT(AttLocation.q, AttLocation.t), t);
  481.                                 const Vec3 vRodDefN = AttLocationLerp.q.GetColumn0(); //this is the Cone-Axis
  482.                                 const Vec3 vStiffnessTarget = Quat(m_rollc, m_rolls * vRodDefN) * Quat(m_pitchc, m_pitchs * hn) * vRodDefN;
  483.                                 const Vec3 vAcceleration = vStiffnessTarget * m_fJointSpring * fInvMass - dm.m_vBobVelocity * arrDamping[i] - Vec3(0, 0, m_fGravity);
  484.                                 dm.m_vBobVelocity = (dm.m_vBobPosition - arrPrevBobPositions[i]) / dt + 0.5f * vAcceleration * dt; //Implicit Integral: set correct initial velocity for next frame
  485.                                 f32 len = dm.m_vBobVelocity.GetLength();
  486.                                 if (len > m_fMaxVelocity)
  487.                                         dm.m_vBobVelocity = dm.m_vBobVelocity / len * m_fMaxVelocity;
  488.                         }
  489.  
  490.                         Quat raddTransformation = Quat(R.w, R.v * AttLocation.q).GetNormalized();
  491.                         if (nAllowRedirect)
  492.                         {
  493.                                 const CDefaultSkeleton& rDefaultSkeleton = *pSkelInstance->m_pDefaultSkeleton;
  494.                                 QuatT& ajt = (QuatT&)rPoseData.GetJointAbsolute(dm.m_jointID);
  495.                                 ajt.q.SetNlerp(ajt.q, absJoint.q * raddTransformation, t);
  496.                                 const uint32 p = rDefaultSkeleton.GetJointParentIDByID(dm.m_jointID);
  497.                                 rPoseData.SetJointRelative(dm.m_jointID, rPoseData.GetJointAbsolute(p).GetInverted() * ajt);
  498.                                 if (dm.m_childID != JointIdType(-1))
  499.                                 {
  500.                                         const uint32 id = dm.m_childID;
  501.                                         const uint32 pid = rDefaultSkeleton.GetJointParentIDByID(id);
  502.                                         rPoseData.SetJointAbsolute(id, rPoseData.GetJointAbsolute(pid) * rPoseData.GetJointRelative(id));
  503.                                 }
  504.                         }
  505.  
  506.                         dm.m_vAttModelRelativePrev = rPhysLocation.q * absJoint.t;
  507.  
  508.                         dm.m_vLocationPrev.q = AttLocation.q;
  509.                         dm.m_vLocationPrev.t = AttLocation.t;
  510.                 } //loop over all particles in the row
  511.  
  512.                 if (m_fTimeAccumulator >= fPhysFramerate)
  513.                         m_fTimeAccumulator -= fPhysFramerate;
  514.  
  515. #ifdef EDITOR_PCDEBUGCODE
  516.                 uint32 nDrawDynamicProxies = ((m_vCapsule.x + m_vCapsule.y) && (pAttachmentManager->m_nDrawProxies & 1));
  517.                 if (nDrawDynamicProxies || m_useDebugSetup || Console::GetInst().ca_DrawAllSimulatedSockets)
  518.                 {
  519.                         g_pAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def3DPublicRenderflags));
  520.  
  521.                         for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  522.                         {
  523.                                 Particle& dm = m_arrParticles[i];
  524.                                 Vec3 naxis = (dm.m_vBobPosition - arrLinks[i]).GetNormalized();
  525.                                 arrParticles[i] = naxis * dm.m_vDistance.y + arrLinks[i];
  526.                         }
  527.  
  528.                         for (uint32 i = 0; i < m_nParticlesPerRow && nBindPose == 0; i++)
  529.                         {
  530.                                 uint32 i0 = i;
  531.                                 uint32 i1 = (i + 1) % m_nParticlesPerRow;
  532.                                 Vec3 p0 = arrParticles[i0];
  533.                                 Vec3 p1 = arrParticles[i1];
  534.                                 if (i0 < i1 || m_cycle)
  535.                                         g_pAuxGeom->DrawLine(p0, RGBA8(0xff, 0x00, 0x00, 0x00), p1, RGBA8(0xff, 0x00, 0x00, 0x00));
  536.                                 if (m_useDebugSetup || Console::GetInst().ca_DrawAllSimulatedSockets)
  537.                                         IRenderAuxText::DrawLabelF(p0, 1, "%d", i0);
  538.                         }
  539.                 }
  540. #endif
  541.  
  542.         }
  543.  
  544.         //-------------------------------------------------------------------------------------
  545.         //-------------------------------------------------------------------------------------
  546.         //-------------------------------------------------------------------------------------
  547.  
  548. #ifdef EDITOR_PCDEBUGCODE
  549.         uint32 nDrawDynamicProxies = ((m_vCapsule.x + m_vCapsule.y) && (pAttachmentManager->m_nDrawProxies & 1));
  550.         if (nDrawDynamicProxies || m_useDebugSetup || Console::GetInst().ca_DrawAllSimulatedSockets)
  551.         {
  552.                 for (uint32 i = 0; i < m_nParticlesPerRow; i++)
  553.                 {
  554.                         Particle& dm = m_arrParticles[i];
  555.                         const int nJointID = dm.m_jointID;
  556.                         const QuatTS AttLocation = rPhysLocation * remJointLocation[i] * qyz;
  557.                         const Vec3 vRodAnimN = (dm.m_vBobPosition - AttLocation.t) * isqrt_tpl(sqr(dm.m_vBobPosition - AttLocation.t));
  558.                         g_pAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def3DPublicRenderflags));
  559.                         const QuatT absJoint = rPoseData.GetJointAbsolute(nJointID);
  560.                         QuatTS caplocation = rPhysLocation * absJoint;
  561.                         QuatTS cloc(Quat::CreateRotationV0V1(Vec3(1, 0, 0), vRodAnimN), vRodAnimN * m_vCapsule.x + caplocation.t, caplocation.s);
  562.                         Draw(cloc, arrSetupError[i] ? RGBA8(0xef, 0x3f, 0x1f, 0xff) : RGBA8(0x67, 0xa0, 0xbc, 0xff), 4, pSkelInstance->m_Viewdir);
  563.                         uint32 res = (m_useDebugSetup || Console::GetInst().ca_DrawAllSimulatedSockets);
  564.                         if (res)
  565.                         {
  566.                                 g_pAuxGeom->DrawLine(dm.m_vBobPosition, RGBA8(0x0f, 0x0f, 0x7f, 0x00), dm.m_vBobPosition + dm.m_vBobVelocity, RGBA8(0x00, 0x00, 0xff, 0x00));
  567.  
  568.                                 Vec3 points[0x2000];
  569.                                 ColorB col0 = RGBA8(0x00, 0xff, 0x00, 0x00);
  570.                                 ColorB col1 = RGBA8(0x00, 0x7f, 0x00, 0x00);
  571.  
  572.                                 //-----------------------------------------------------------------
  573.                                 const Vec3 vSimulationAxisN = Vec3(1, 0, 0);
  574.  
  575.                                 Quat hrot = qx;
  576.  
  577.                                 Vec3 ortho1 = hrot.GetColumn2();//*vSimulationAxisO;
  578.                                 Vec3 ortho2 = ortho1 % vSimulationAxisN;
  579.                                 Matrix33 m33;
  580.                                 m33.SetFromVectors(ortho1, vSimulationAxisN, ortho2);
  581.                                 assert(m33.IsOrthonormalRH());
  582.  
  583.                                 {
  584.                                         f32 bsize = m_fRodLength;
  585.                                         Vec3 vPAxis = (dm.m_vBobPosition - AttLocation.t) * caplocation.s;
  586.                                         g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0xff, 0xff, 0x00, 0x00), AttLocation.t + vPAxis, RGBA8(0xff, 0xff, 0x00, 0x00));
  587.                                         g_pAuxGeom->DrawSphere(AttLocation.t + vPAxis, 0.05f * bsize * caplocation.s, RGBA8(0x00, 0xff, 0xff, 0));
  588.  
  589.                                         const Vec3 vRodDefN = AttLocation.q * vSimulationAxisN * caplocation.s;
  590.                                         g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0x0f, 0x0f, 0x0f, 0x00), AttLocation.t + vRodDefN * m_fRodLength, RGBA8(0xff, 0xff, 0xff, 0x00));
  591.  
  592.                                         Vec3 hnormal = (AttLocation.q * hrot).GetColumn2();//*vSimulationAxisO;
  593.                                         Vec3 vStiffnessTarget = Quat(m_rollc, m_rolls * vRodDefN) * Quat(m_pitchc, m_pitchs * hnormal) * vRodDefN * m_fRodLength;
  594.                                         g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0xff, 0xff, 0xff, 0x00), AttLocation.t + vStiffnessTarget, RGBA8(0xff, 0xff, 0xff, 0x00));
  595.                                         g_pAuxGeom->DrawSphere(AttLocation.t + vStiffnessTarget, 0.04f * bsize * caplocation.s, RGBA8(0xff, 0xff, 0xff, 0));
  596.                                         g_pAuxGeom->DrawSphere(caplocation.t, 0.03f * bsize * caplocation.s, RGBA8(0xff, 0x00, 0x00, 0));
  597.                                 }
  598.                                 const Vec3 caxis = Vec3(0.3f, 0, 0);
  599.                                 if (m_nClampMode == RowSimulationParams::PENDULUM_HALF_CONE || m_nClampMode == RowSimulationParams::PENDULUM_CONE)
  600.                                 {
  601.                                         f32 fMaxRad = HCOS2RAD(m_fMaxAngleHCos);
  602.                                         for (f32 r = -fMaxRad; r < fMaxRad; r += 0.05f)
  603.                                         {
  604.                                                 Vec3 rvec = Quat::CreateRotationAA(r, ortho1) * caxis;
  605.                                                 g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0x3f, 0x3f, 0x3f, 0x00), AttLocation * rvec, col1);
  606.                                         }
  607.                                         uint32 i0 = 0;
  608.                                         for (f32 r = -fMaxRad; r < fMaxRad; r = r + 0.01f)
  609.                                                 points[i0++] = AttLocation * (Matrix33::CreateRotationAA(r, ortho1) * caxis);
  610.                                         g_pAuxGeom->DrawPoints(points, i0, col0);
  611.  
  612.                                         if (m_nClampMode == RowSimulationParams::PENDULUM_CONE)
  613.                                         {
  614.                                                 f32 steps = (gf_PI2 / 100.0f);
  615.                                                 uint32 c = 0;
  616.                                                 Vec3 cvec = Quat::CreateRotationAA(m_fMaxAngleHCos, fMaxAngleHSin, ortho1) * caxis;
  617.                                                 for (f32 r = -gf_PI; r < (gf_PI + steps); r += steps)
  618.                                                 {
  619.                                                         Vec3 rvec = Quat::CreateRotationAA(r, vSimulationAxisN) * cvec;
  620.                                                         points[c++] = AttLocation * rvec;
  621.                                                 }
  622.                                                 c--;
  623.  
  624.                                                 SAuxGeomRenderFlags renderFlags(e_Def3DPublicRenderflags);
  625.                                                 renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  626.                                                 renderFlags.SetDrawInFrontMode(e_DrawInFrontOn);
  627.                                                 renderFlags.SetFillMode(e_FillModeSolid);
  628.                                                 g_pAuxGeom->SetRenderFlags(renderFlags);
  629.                                                 vtx_idx arrIndices[400];
  630.                                                 Vec3 arrVertices[400];
  631.                                                 ColorB arrVColors[400];
  632.                                                 uint32 numVertices = 0;
  633.                                                 for (uint32 n = 0; n < c; n++)
  634.                                                 {
  635.                                                         arrVertices[numVertices + 0] = points[n + 0];
  636.                                                         arrVColors[numVertices + 0] = RGBA8(0x00, 0x1f, 0x00, 0xcf);
  637.                                                         arrVertices[numVertices + 1] = points[n + 1];
  638.                                                         arrVColors[numVertices + 1] = RGBA8(0x00, 0x1f, 0x00, 0xcf);
  639.                                                         arrVertices[numVertices + 2] = AttLocation.t;
  640.                                                         arrVColors[numVertices + 2] = RGBA8(0x07, 0x07, 0x07, 0xcf);
  641.                                                         arrIndices[numVertices + 0] = numVertices + 0;
  642.                                                         arrIndices[numVertices + 1] = numVertices + 1;
  643.                                                         arrIndices[numVertices + 2] = numVertices + 2;
  644.                                                         numVertices += 3;
  645.                                                 }
  646.                                                 g_pAuxGeom->DrawTriangles(&arrVertices[0], numVertices, arrIndices, numVertices, &arrVColors[0]);
  647.                                                 numVertices = 0;
  648.                                                 for (uint32 n = 0; n < c; n++)
  649.                                                 {
  650.                                                         arrVertices[numVertices + 0] = points[n + 1];
  651.                                                         arrVColors[numVertices + 0] = RGBA8(0x00, 0x9f, 0x00, 0x7f);
  652.                                                         arrVertices[numVertices + 1] = points[n + 0];
  653.                                                         arrVColors[numVertices + 1] = RGBA8(0x00, 0x9f, 0x00, 0x7f);
  654.                                                         arrVertices[numVertices + 2] = AttLocation.t;
  655.                                                         arrVColors[numVertices + 2] = RGBA8(0x0f, 0x0f, 0x07, 0x7f);
  656.                                                         numVertices += 3;
  657.                                                 }
  658.                                                 g_pAuxGeom->DrawTriangles(&arrVertices[0], numVertices, arrIndices, numVertices, &arrVColors[0]);
  659.                                         }
  660.  
  661.                                         if (m_nClampMode == RowSimulationParams::PENDULUM_HALF_CONE)
  662.                                         {
  663.                                                 Vec3 cvec = Quat::CreateRotationAA(m_fMaxAngleHCos, fMaxAngleHSin, ortho1) * caxis;
  664.                                                 f32 steps = (gf_PI2 / 100.0f);
  665.                                                 uint32 c = 0;
  666.                                                 for (f32 r = -gf_PI; r < (gf_PI + steps); r += steps)
  667.                                                 {
  668.                                                         Vec3 rvec = Quat::CreateRotationAA(r, vSimulationAxisN) * cvec;
  669.                                                         Vec3 o = rvec * m33;
  670.                                                         if (o.x > 0.0f) o.x = 0;
  671.                                                         rvec = m33 * o;
  672.                                                         points[c++] = AttLocation * rvec;
  673.                                                 }
  674.                                                 c--;
  675.  
  676.                                                 SAuxGeomRenderFlags renderFlags(e_Def3DPublicRenderflags);
  677.                                                 renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  678.                                                 renderFlags.SetDrawInFrontMode(e_DrawInFrontOn);
  679.                                                 renderFlags.SetFillMode(e_FillModeSolid);
  680.                                                 g_pAuxGeom->SetRenderFlags(renderFlags);
  681.                                                 vtx_idx arrIndices[400];
  682.                                                 Vec3 arrVertices[400];
  683.                                                 ColorB arrVColors[400];
  684.                                                 uint32 numVertices = 0;
  685.                                                 for (uint32 n = 0; n < c; n++)
  686.                                                 {
  687.                                                         arrVertices[numVertices + 0] = points[n + 0];
  688.                                                         arrVColors[numVertices + 0] = RGBA8(0x00, 0x1f, 0x00, 0xcf);
  689.                                                         arrVertices[numVertices + 1] = points[n + 1];
  690.                                                         arrVColors[numVertices + 1] = RGBA8(0x00, 0x1f, 0x00, 0xcf);
  691.                                                         arrVertices[numVertices + 2] = AttLocation.t;
  692.                                                         arrVColors[numVertices + 2] = RGBA8(0x07, 0x07, 0x07, 0xcf);
  693.                                                         arrIndices[numVertices + 0] = numVertices + 0;
  694.                                                         arrIndices[numVertices + 1] = numVertices + 1;
  695.                                                         arrIndices[numVertices + 2] = numVertices + 2;
  696.                                                         numVertices += 3;
  697.                                                 }
  698.                                                 g_pAuxGeom->DrawTriangles(&arrVertices[0], numVertices, arrIndices, numVertices, &arrVColors[0]);
  699.                                                 numVertices = 0;
  700.                                                 for (uint32 n = 0; n < c; n++)
  701.                                                 {
  702.                                                         arrVertices[numVertices + 0] = points[n + 1];
  703.                                                         arrVColors[numVertices + 0] = RGBA8(0x00, 0x9f, 0x00, 0x7f);
  704.                                                         arrVertices[numVertices + 1] = points[n + 0];
  705.                                                         arrVColors[numVertices + 1] = RGBA8(0x00, 0x9f, 0x00, 0x7f);
  706.                                                         arrVertices[numVertices + 2] = AttLocation.t;
  707.                                                         arrVColors[numVertices + 2] = RGBA8(0x0f, 0x0f, 0x07, 0x7f);
  708.                                                         numVertices += 3;
  709.                                                 }
  710.                                                 g_pAuxGeom->DrawTriangles(&arrVertices[0], numVertices, arrIndices, numVertices, &arrVColors[0]);
  711.                                         }
  712.                                 }
  713.  
  714.                                 if (m_nClampMode == RowSimulationParams::PENDULUM_HINGE_PLANE)
  715.                                 {
  716.                                         f32 fMaxRad = HCOS2RAD(m_fMaxAngleHCos);
  717.                                         for (f32 r = -fMaxRad; r < fMaxRad; r += 0.05f)
  718.                                         {
  719.                                                 f32 t0 = (r + fMaxRad) / (fMaxRad * 2);
  720.                                                 f32 t1 = 1.0f - t0;
  721.                                                 Vec3 rvec = Quat::CreateRotationAA(r, ortho1) * caxis;
  722.                                                 g_pAuxGeom->DrawLine(AttLocation.t, RGBA8(0x3f, 0x3f, 0x3f, 0x00), AttLocation * rvec, RGBA8(uint8(0x00 * t0 + 0x7f * t1), uint8(0x7f * t0 + 0x00 * t1), 0x00, 0x00));
  723.                                         }
  724.                                         uint32 i0 = 0;
  725.                                         for (f32 r = -fMaxRad; r < fMaxRad; r = r + 0.01f)
  726.                                                 points[i0++] = AttLocation * (Matrix33::CreateRotationAA(r, ortho1) * caxis);
  727.                                         g_pAuxGeom->DrawPoints(points, i0, col0);
  728.                                 }
  729.                         } // if(res)
  730.  
  731.                 } //for loop
  732.  
  733.         }
  734.  
  735. #endif
  736.  
  737. }
  738.  
  739. void CPendulaRow::Draw(const QuatTS& qt, const ColorB clr, const uint32 tesselation, const Vec3& vdir)
  740. {
  741.         uint32 subdiv = 4 * tesselation;
  742.         uint32 stride = (subdiv + 1) * (tesselation + 1);
  743.         Matrix34 m34 = Matrix34(qt);
  744.         Matrix33 m33 = Matrix33(m34);
  745.         Matrix33 my(IDENTITY), rely;
  746.         rely.SetRotationY(gf_PI2 / f32(subdiv));
  747.         Matrix33 mx(IDENTITY), relx;
  748.         relx.SetRotationX(gf_PI2 / f32(subdiv));
  749.         Vec3 ldir0 = Vec3(vdir.x, vdir.y, 0).GetNormalized() * 0.5f;
  750.         ldir0.z = f32(sqrt3 * -0.5f);
  751.         Vec3 ldir1(0, 0, 1);
  752.         f32 ca = m_vCapsule.x, cr = m_vCapsule.y;
  753.         Vec3 p3d[0x2000], _p[0x2000];
  754.         ColorB c3d[0x2000], _c[0x2000];
  755.         static struct
  756.         {
  757.                 ILINE ColorB shader(Vec3 n, const Vec3& d0, const Vec3& d1, ColorB c)
  758.                 {
  759.                         f32 a = 0.5f * n | d0, b = 0.1f * n | d1, l = min(1.0f, fabs_tpl(a) - a + fabs_tpl(b) - b + 0.05f);
  760.                         return RGBA8(uint8(l * c.r), uint8(l * c.g), uint8(l * c.b), c.a);
  761.                 }
  762.         } s;
  763.         for (uint32 a = 0, b = 0; a < tesselation + 1; a++, my *= rely)
  764.         {
  765.                 mx.SetIdentity();
  766.                 for (uint32 i = 0; i < subdiv + 1; i++, b++, mx *= relx)
  767.                 {
  768.                         Vec3 v = mx * Vec3(my.m02, my.m12, my.m22);
  769.                         p3d[b] = m34 * Vec3(-ca - v.x * cr, v.y * cr, v.z * cr);
  770.                         p3d[b + stride] = m34 * Vec3(+ca + v.x * cr, v.y * cr, v.z * cr);
  771.                         c3d[b] = s.shader(m33 * Vec3(-v.x, v.y, v.z), ldir0, ldir1, clr);
  772.                         c3d[b + stride] = s.shader(m33 * Vec3(v.x, v.y, v.z), ldir0, ldir1, clr);
  773.                 }
  774.         }
  775.         uint32 c = 0, p = 0;
  776.         for (uint32 i = 0; i < subdiv; i++)
  777.         {
  778.                 _p[p++] = p3d[i + 0], _c[c++] = c3d[i + 0], _p[p++] = p3d[i + stride + 0], _c[c++] = c3d[i + stride + 0];
  779.                 _p[p++] = p3d[i + 1], _c[c++] = c3d[i + 1], _p[p++] = p3d[i + stride + 1], _c[c++] = c3d[i + stride + 1];
  780.                 _p[p++] = p3d[i + 1], _c[c++] = c3d[i + 1], _p[p++] = p3d[i + stride + 0], _c[c++] = c3d[i + stride + 0];
  781.         }
  782.         for (uint32 a = 0, vc = 0; a < tesselation; a++, vc++)
  783.         {
  784.                 for (uint32 i = 0; i < subdiv; i++, vc++)
  785.                 {
  786.                         _p[p++] = p3d[vc + 1], _c[c++] = c3d[vc + 1], _p[p++] = p3d[vc + subdiv + 1], _c[c++] = c3d[vc + subdiv + 1];
  787.                         _p[p++] = p3d[vc + 0], _c[c++] = c3d[vc + 0], _p[p++] = p3d[vc + subdiv + 1], _c[c++] = c3d[vc + subdiv + 1];
  788.                         _p[p++] = p3d[vc + 1], _c[c++] = c3d[vc + 1], _p[p++] = p3d[vc + subdiv + 2], _c[c++] = c3d[vc + subdiv + 2];
  789.                         _p[p++] = p3d[vc + 0 + stride], _c[c++] = c3d[vc + 0 + stride], _p[p++] = p3d[vc + stride + subdiv + 1], _c[c++] = c3d[vc + stride + subdiv + 1];
  790.                         _p[p++] = p3d[vc + 1 + stride], _c[c++] = c3d[vc + 1 + stride], _p[p++] = p3d[vc + stride + subdiv + 2], _c[c++] = c3d[vc + stride + subdiv + 2];
  791.                         _p[p++] = p3d[vc + 1 + stride], _c[c++] = c3d[vc + 1 + stride], _p[p++] = p3d[vc + stride + subdiv + 1], _c[c++] = c3d[vc + stride + subdiv + 1];
  792.                 }
  793.         }
  794.         uint32 rflag = e_Mode3D | e_AlphaNone | e_DrawInFrontOff | e_FillModeSolid | e_CullModeNone | e_DepthWriteOn | e_DepthTestOn;
  795.         SAuxGeomRenderFlags renderFlags(rflag);
  796.         g_pAuxGeom->SetRenderFlags(renderFlags);
  797.         g_pAuxGeom->DrawTriangles(&_p[0], p, &_c[0]);
  798. }
  799.  
downloadAttachmentPRow.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top