BVB Source Codes

CRYENGINE Show AttachmentVCloth.h Source code

Return Download CRYENGINE: download AttachmentVCloth.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #pragma once
  4.  
  5. #include "AttachmentBase.h"
  6. #include "Vertex/VertexData.h"
  7. #include "Vertex/VertexAnimation.h"
  8. #include "ModelSkin.h"
  9. #include "SkeletonPose.h"
  10. #include "AttachmentVClothPreProcess.h"
  11.  
  12. class CCharInstance;
  13. class CClothProxies;
  14. class CAttachmentManager;
  15. struct SVertexAnimationJob;
  16. class CClothPhysics;
  17. struct SBuffers;
  18.  
  19. typedef Vec3     Vector4;
  20. typedef Matrix33 Matrix3;
  21. typedef Quat     Quaternion;
  22.  
  23. inline Vec3 SseToVec3(const Vector4& v)
  24. {
  25.         return v;
  26. }
  27.  
  28. inline Quat SseToQuat(const Quaternion& q)
  29. {
  30.         return q;
  31. }
  32.  
  33. enum ECollisionPrimitiveType
  34. {
  35.         eCPT_Invalid,
  36.         eCPT_Capsule,
  37.         eCPT_Sphere,
  38. };
  39.  
  40. struct SPrimitive
  41. {
  42.         ECollisionPrimitiveType type;
  43.         SPrimitive() : type(eCPT_Invalid) {}
  44.         virtual ~SPrimitive() {}
  45. };
  46.  
  47. struct SSphere : SPrimitive
  48. {
  49.         Vector4 center;
  50.         float   r;
  51.         SSphere()
  52.                 : center(ZERO)
  53.                 , r(0.0f)
  54.         {
  55.                 type = eCPT_Sphere;
  56.         }
  57. };
  58.  
  59. struct SCapsule : SPrimitive
  60. {
  61.         Vector4 axis, center;
  62.         float   hh, r;
  63.         SCapsule()
  64.                 : axis(ZERO)
  65.                 , center(ZERO)
  66.                 , hh(0.0f)
  67.                 , r(0.0f)
  68.         {
  69.                 type = eCPT_Capsule;
  70.         }
  71. };
  72.  
  73. enum EPhysicsLayer
  74. {
  75.         PHYS_LAYER_INVALID,
  76.         PHYS_LAYER_ARTICULATED,
  77.         PHYS_LAYER_CLOTH,
  78. };
  79.  
  80. struct SPhysicsGeom
  81. {
  82.         SPrimitive*   primitive;
  83.         EPhysicsLayer layer;
  84.  
  85.         SPhysicsGeom()
  86.                 : primitive(nullptr)
  87.                 , layer(PHYS_LAYER_INVALID)
  88.         {}
  89. };
  90.  
  91. struct SBonePhysics
  92. {
  93.         quaternionf q;
  94.         Vec3        t;
  95.         f32         cr, ca;
  96.  
  97.         SBonePhysics()
  98.         {
  99.                 cr = 0;
  100.                 ca = 0;
  101.                 t = Vec3(ZERO);
  102.                 q.SetIdentity();
  103.         }
  104. };
  105.  
  106. struct STangents
  107. {
  108.         Vector4 t, n;
  109.         STangents()
  110.         {
  111.                 t.zero();
  112.                 n.zero();
  113.         }
  114. };
  115.  
  116. struct SBuffers
  117. {
  118.         // temporary buffer for simulated cloth vertices
  119.         DynArray<Vector4>    m_tmpClothVtx;
  120.         std::vector<Vector4> m_normals;
  121.  
  122.         // output buffers for sw-skinning
  123.         DynArray<Vec3>         m_arrDstPositions;
  124.         DynArray<SPipTangents> m_arrDstTangents; // TODO: static
  125.  
  126.         std::vector<STangents> m_tangents;
  127. };
  128.  
  129. struct SSkinMapEntry
  130. {
  131.         int   iMap; // vertex index in the sim mesh
  132.         int   iTri; // triangle index in the sim mesh
  133.         float s, t; // barycentric coordinates in the adjacent triangle
  134.         float h;    // distance from triangle
  135. };
  136.  
  137. struct STangentData
  138. {
  139.         float t1, t2, r;
  140. };
  141.  
  142. struct SClothGeometry
  143. {
  144.         enum
  145.         {
  146.                 MAX_LODS = 2,
  147.         };
  148.  
  149.         // the number of vertices in the sim mesh
  150.         int            nVtx;
  151.         // registered physical geometry constructed from sim mesh
  152.         phys_geometry* pPhysGeom;
  153.         // mapping between original mesh and welded one
  154.         vtx_idx*       weldMap;
  155.         // number of non-welded vertices in the sim mesh
  156.         int            nUniqueVtx;
  157.         // blending weights between skinning and sim (coming from vertex colors)
  158.         float*         weights;
  159.         // mapping between render mesh and sim mesh vertices
  160.         SSkinMapEntry* skinMap[MAX_LODS];
  161.         // render mesh indices
  162.         uint           numIndices[MAX_LODS];
  163.         vtx_idx*       pIndices[MAX_LODS];
  164.         // tangent frame uv data
  165.         STangentData*  tangentData[MAX_LODS];
  166.         // maximum number for vertices (for LOD0)
  167.         int            maxVertices;
  168.  
  169.         // memory pool. keeping it as a list for now to avoid reallocation
  170.         // because the jobs are using pointers inside it
  171.         std::list<SBuffers> pool;
  172.         std::vector<int>    freePoolSlots;
  173.         volatile int        poolLock;
  174.  
  175.         SClothGeometry()
  176.                 : nVtx(0)
  177.                 , pPhysGeom(NULL)
  178.                 , weldMap(NULL)
  179.                 , nUniqueVtx(0)
  180.                 , weights(NULL)
  181.                 , poolLock(0)
  182.                 , maxVertices(0)
  183.         {
  184.                 for (int i = 0; i < MAX_LODS; i++)
  185.                 {
  186.                         skinMap[i] = NULL;
  187.                         pIndices[i] = NULL;
  188.                         tangentData[i] = NULL;
  189.                 }
  190.         }
  191.  
  192.         void      Cleanup();
  193.         int       GetBuffers();
  194.         void      ReleaseBuffers(int idx);
  195.         SBuffers* GetBufferPtr(int idx);
  196.         void      AllocateBuffer();
  197. };
  198.  
  199. struct SClothInfo
  200. {
  201.         uint64 key;
  202.         float  distance;
  203.         bool   visible;
  204.         int    frame;
  205.  
  206.         SClothInfo() {}
  207.         SClothInfo(uint64 k, float d, bool v, int f) : key(k), distance(d), visible(v), frame(f) {}
  208. };
  209.  
  210. struct SPrimitive;
  211.  
  212. struct SParticleCold
  213. {
  214.         Vector4 prevPos;
  215.         Vector4 oldPos;
  216.         Vector4 skinnedPos;
  217.         int     permIdx;
  218.         int     bAttached;
  219.  
  220.         SParticleCold()
  221.         {
  222.                 prevPos.zero();
  223.                 bAttached = 0;
  224.                 skinnedPos.zero();
  225.                 permIdx = -1;
  226.                 oldPos.zero();
  227.         }
  228. };
  229.  
  230. struct SParticleHot
  231. {
  232.         Vector4 pos;
  233.  
  234.         float   alpha;          //!< for blending with animation; == 0 if unconstrained .. == 1.0 if attached
  235.         float   factorAttached; //!< == 0 if attached .. == 1.0 if unconstrained; i.e. 1.0f-alpha
  236.         int     timer;
  237.  
  238.         bool    collisionExist;  //!< set to true, if a collision occurs
  239.         Vector4 collisionNormal; //!< stores collision normal for damping in tangential direction
  240.  
  241.         // long range attachments
  242.         int   lraIdx;        //!< index of closest constraint / attached vtx
  243.         float lraDist;       //!< distance to closest constraint
  244.         int   lraNextParent; //!< index of next parent on path to closest constraint
  245.  
  246.         SParticleHot() : collisionExist(false), timer(0), alpha(0), lraIdx(-1), lraDist(0), lraNextParent(-1), collisionNormal(ZERO), pos(ZERO)
  247.         {
  248.         }
  249. };
  250.  
  251. struct SCollidable
  252. {
  253.         Matrix3 R, oldR;
  254.         QuatT   qLerp; //!< interpolation [R,oldR & translation] for substeps
  255.  
  256.         Vector4 offset, oldOffset;
  257.         f32     cr, cx, cy, cz; //!< lozenge definition
  258.  
  259.         SCollidable()
  260.                 : R(IDENTITY)
  261.                 , oldR(IDENTITY)
  262.                 , offset(ZERO)
  263.                 , oldOffset(ZERO)
  264.                 , cr(0.0f)
  265.                 , cx(0.0f)
  266.                 , cy(0.0f)
  267.                 , cz(0.0f)
  268.         {
  269.         }
  270. };
  271.  
  272. class CClothSimulator
  273. {
  274. public:
  275.  
  276.         CClothSimulator()
  277.                 : m_pAttachmentManager(nullptr)
  278.                 , m_nVtx(0)
  279.                 , m_nEdges(0)
  280.                 , m_particlesCold(nullptr)
  281.                 , m_particlesHot(nullptr)
  282.                 , m_links(nullptr)
  283.                 , m_gravity(0, 0, -9.8f)
  284.                 , m_time(0.0f)
  285.                 , m_dt(0.0f)
  286.                 , m_dtPrev(-1)
  287.                 , m_dtNormalize(100.0f) // i.e. normalize substep to 1/dt with dt = 0.01
  288.                 , m_steps(0)
  289.                 , m_normalizedTimePrev(0)
  290.                 , m_doSkinningForNSteps(0)
  291.                 , m_fadeInOutPhysicsDirection(0)
  292.                 , m_fadeTimeActual(0) // physical fade time
  293.                 , m_bUseDijkstraForLRA(true)
  294.                 , m_bIsInitialized(false)
  295.         {
  296.         }
  297.  
  298.         ~CClothSimulator()
  299.         {
  300.                 SAFE_DELETE_ARRAY(m_particlesHot);
  301.                 SAFE_DELETE_ARRAY(m_particlesCold);
  302.                 SAFE_DELETE_ARRAY(m_links);
  303.         }
  304.  
  305.         /**
  306.          * Disable simulation totally, e.g., if camera is far away.
  307.          */
  308.         void                 EnableSimulation(bool enable = true)   { m_config.disableSimulation = !enable; }
  309.         bool                 IsSimulationEnabled() const            { return !m_config.disableSimulation; }
  310.  
  311.         const SVClothParams& GetParams() const                      { return m_config; };
  312.         void                 SetParams(const SVClothParams& params) { m_config = params; };
  313.         int                  SetParams(const SVClothParams& params, float* weights);
  314.  
  315.         void                 StartStep(float time_interval, const QuatT& location);
  316.         int                  Step();
  317.  
  318.         bool                 AddGeometry(phys_geometry* pgeom);
  319.         void                 SetSkinnedPositions(const Vector4* points);
  320.         void                 GetVertices(Vector4* pWorldCoords) const;
  321.         void                 GetVerticesFaded(Vector4* pWorldCoords);
  322.  
  323.         /**
  324.          * Laplace-filter for input-positions, using the default mesh-edges.
  325.          */
  326.         void LaplaceFilterPositions(Vector4* positions, float intensity);
  327.  
  328.         /**
  329.          * Enable skinning/physics according to camera distance.
  330.          */
  331.         void HandleCameraDistance();
  332.         void SetInitialized(bool initialized = true) { m_bIsInitialized = initialized; }
  333.         bool IsInitialized() const                   { return m_bIsInitialized; }
  334.  
  335.         // fading/blending between skinning and simulation
  336.         bool IsFading() const { return (m_fadeTimeActual > 0.0f) || (m_fadeInOutPhysicsDirection != 0); }
  337.         void DecreaseFadeInOutTimer(float dt);
  338.  
  339.         void DrawHelperInformation();
  340.  
  341.         void SetAttachmentManager(const CAttachmentManager* am) { m_pAttachmentManager = am; }
  342.  
  343.         /**
  344.          * Get metadata from skin.
  345.          */
  346.         bool GetMetaData(mesh_data* pMesh, CSkin* pSimSkin);
  347.  
  348.         /**
  349.          * Generate metadata on the fly.
  350.          */
  351.         void GenerateMetaData(mesh_data* pMesh, CSkin* pSimSkin, float* weights);
  352.  
  353. private:
  354.  
  355.         void PrepareEdge(SLink& link);
  356.         void SolveEdge(const SLink& link, float stretch);
  357.         void DampEdge(const SLink& link, f32 damping);
  358.         void DampTangential();
  359.         void DampPositionBasedDynamics();
  360.         void PositionsIntegrate();
  361.         void PositionsPullToSkinnedPositions();
  362.  
  363.         /**
  364.          * Set skinning positions; e.g. to reduce strong simulation forces when simulation is enabled/faded in.
  365.          */
  366.         void PositionsSetToSkinned(bool projectToProxySurface = true, bool setPosOld = true);
  367.         void PositionsSetAttachedToSkinnedInterpolated(float t01);
  368.  
  369.         /**
  370.          * Moves particle-positions 'm_particlesHot[i].pos' lying inside proxy to proxies surface; using time-interpolation if t01 is set.
  371.          */
  372.         void PositionsProjectToProxySurface(f32 t01 = 1.0f);
  373.         void BendByTriangleAngleDetermineNormals();
  374.         void BendByTriangleAngleSolve(float kBend);
  375.  
  376.         /**
  377.          * Determine actual, lerped quaternions for colliders
  378.          */
  379.         void UpdateCollidablesLerp(f32 t01 = 1.0f);
  380.         void LongRangeAttachmentsSolve();
  381.  
  382.         /**
  383.          * Check distance to camera.
  384.          * @return True, if distance to camera is les than value; false, otherwise.
  385.          */
  386.         bool CheckCameraDistanceLessThan(float dist) const;
  387.         /**
  388.          * Check framerate.
  389.          * @return True, if framerate is less than m_config.forceSkinningFpsThreshold; false otherwise.
  390.          */
  391.         bool CheckForceSkinningByFpsThreshold();
  392.         bool CheckForceSkinning();
  393.  
  394.         /**
  395.          * Detect rewind from end to start of animation.
  396.          */
  397.         bool CheckAnimationRewind();
  398.         void DoForceSkinning();
  399.         void DoAnimationRewind();
  400.  
  401.         // fading
  402.         bool IsFadingOut() const { return (m_fadeTimeActual > 0.0f) && (m_fadeInOutPhysicsDirection == -1); }
  403.         bool IsFadingIn()  const { return (m_fadeTimeActual > 0.0f) && (m_fadeInOutPhysicsDirection == 1); }
  404.         void InitFadeInOutPhysics();
  405.         void EnableFadeOutPhysics();
  406.         void EnableFadeInPhysics();
  407.  
  408.         void DebugOutput(float stepTime01);
  409.  
  410. private:
  411.  
  412.         bool                      m_bIsInitialized;
  413.         bool                      m_bUseDijkstraForLRA; //!< defaults to true; if set to false euklidean distances are used, which does not work very well, since in strange poses particles are pulled through the body (e.g. in case of bending down)
  414.         ColorB                    m_color;
  415.  
  416.         SVClothParams             m_config;
  417.         const CAttachmentManager* m_pAttachmentManager;
  418.  
  419.         int                       m_nVtx;          //!< the number of particles
  420.         int                       m_nEdges;        //!< the number of links between particles
  421.         SParticleCold*            m_particlesCold; //!< the simulation particles
  422.         SParticleHot*             m_particlesHot;  //!< the simulation particles
  423.  
  424.         SLink*                    m_links;        //!< the structural links between particles / stretch links
  425.         std::vector<SLink>        m_shearLinks;   //!< shear links
  426.         std::vector<SLink>        m_bendLinks;    //!< bend links
  427.         Vector4                   m_gravity;      //!< the gravity vector
  428.         float                     m_time;         //!< time accumulator over frames (used to determine the number of sub-steps)
  429.         float                     m_timeInterval; //!< time interval to be simulated for last frame
  430.         float                     m_dt;           //!< dt of actual substep
  431.         float                     m_dtPrev;       //!< dt of previous substep - needed to determine the velocity by posPrev within position based approach
  432.         float                     m_dtNormalize;  //!< normalization factor for dt to convert constants in suitable range
  433.         float                     m_normalizedTimePrev;
  434.         int                       m_steps;
  435.  
  436.         std::vector<SCollidable>  m_permCollidables; //!< list of collision proxies (no collision with the world)
  437.  
  438.         float                     m_fadeTimeActual;            //!< actual fade time
  439.         int                       m_fadeInOutPhysicsDirection; //!< -1 fade out, 1 fade in
  440.         int                       m_doSkinningForNSteps;       //!< use skinning if any position change has occured, to keep simulation stable
  441.  
  442.         Vec3                      m_externalDeltaTranslation; //!< delta translation of locator per timestep; is used to determine external influence according to velocity
  443.         Vec3                      m_permCollidables0Old;      //!< to determine above m_externalDeltaTranslation per step
  444.         QuatT                     m_location;                 //!< global location / not used in the moment
  445.  
  446.         // Long Range Attachments
  447.         std::vector<int> m_lraNotAttachedOrderedIdx; //!< not attached particles: ordered by distance to constraints
  448.  
  449.         // Bending by triangle angles, not springs
  450.         std::vector<SBendTrianglePair> m_listBendTrianglePairs; //!< triangle pairs sharing an edge
  451.         std::vector<SBendTriangle>     m_listBendTriangles;     //!< triangles which are used for bending
  452.  
  453.         // Laplace container
  454.         std::vector<Vec3>  m_listLaplacePosSum;
  455.         std::vector<float> m_listLaplaceN;
  456.  
  457.         // DebugDraw collidables substep interpolation
  458.         int                m_debugCollidableSubsteppingId;
  459.         std::vector<QuatT> m_debugCollidableSubsteppingQuatT; //!< for debug rendering of interpolated proxies
  460. };
  461.  
  462. ILINE void CClothSimulator::PrepareEdge(SLink& link)
  463. {
  464.         int n1 = !(m_particlesCold[link.i1].bAttached);
  465.         int n2 = !(m_particlesCold[link.i2].bAttached);
  466.         link.skip = n1 + n2 == 0;
  467.         if (link.skip)
  468.                 return;
  469.         float m1Inv = n1 ? 1.f : 0.f;
  470.         float m2Inv = n2 ? 1.f : 0.f;
  471.         float mu = 1.0f / (m1Inv + m2Inv);
  472.         float stretch = 1.f;
  473.         link.weight1 = m1Inv * mu * stretch;
  474.         link.weight2 = m2Inv * mu * stretch;
  475. }
  476.  
  477. ILINE void CClothSimulator::SolveEdge(const SLink& link, float stretch)
  478. {
  479.         if (link.skip) return;
  480.         Vector4& v1 = m_particlesHot[link.i1].pos;
  481.         Vector4& v2 = m_particlesHot[link.i2].pos;
  482.         Vector4 delta = v1 - v2;
  483.  
  484.         const float lenSqr = delta.len2();
  485.         delta *= stretch * (lenSqr - link.lenSqr) / (lenSqr + link.lenSqr);
  486.  
  487.         if (!m_particlesCold[link.i1].bAttached) v1 -= link.weight1 * delta * m_dt;
  488.         if (!m_particlesCold[link.i2].bAttached) v2 += link.weight2 * delta * m_dt;
  489.  
  490. }
  491.  
  492. ILINE void CClothSimulator::DampEdge(const SLink& link, f32 damping)
  493. {
  494.         if (link.skip) return;
  495.  
  496.         Vector4& p1 = m_particlesHot[link.i1].pos;
  497.         Vector4& p2 = m_particlesHot[link.i2].pos;
  498.         Vector4 delta = p2 - p1;
  499.  
  500.         Vector4 vel1 = m_particlesHot[link.i1].pos - m_particlesCold[link.i1].prevPos;
  501.         Vector4 vel2 = m_particlesHot[link.i2].pos - m_particlesCold[link.i2].prevPos;
  502.         Vector4 dv = (vel2 - vel1) / m_dtPrev; // relative velocity
  503.  
  504.         // fast determination of dvn for damping (without sqrt), see 'Physically Based Deformable Models in Computer Graphics', Nealen et al
  505.         Vector4 dvn = (dv.dot(delta) / delta.dot(delta)) * delta;
  506.  
  507.         // damp velocity by changing prevPos
  508.         if (!m_particlesCold[link.i1].bAttached) m_particlesCold[link.i1].prevPos -= damping * dvn * m_dt;
  509.         if (!m_particlesCold[link.i2].bAttached) m_particlesCold[link.i2].prevPos += damping * dvn * m_dt;
  510.         // possible variation: change posHot, since prevPos is not used within collision/stiffness loop
  511.         //if (!m_particlesCold[link.i1].bAttached) m_particlesHot[link.i1].pos += damping * dvn;
  512.         //if (!m_particlesCold[link.i2].bAttached) m_particlesHot[link.i2].pos -= damping * dvn;
  513. }
  514.  
  515. class CClothPiece
  516. {
  517. private:
  518.         friend struct VertexCommandClothSkin;
  519.  
  520.         enum
  521.         {
  522.                 HIDE_INTERVAL = 50
  523.         };
  524.  
  525. public:
  526.         CClothPiece()
  527.         {
  528.                 m_pCharInstance = NULL;
  529.                 m_pVClothAttachment = NULL;
  530.                 m_bHidden = false;
  531.                 m_numLods = 0;
  532.                 m_clothGeom = NULL;
  533.                 //      m_bSingleThreaded = false;
  534.                 m_lastVisible = false;
  535.                 m_bAlwaysVisible = false;
  536.                 m_currentLod = 0;
  537.                 m_buffers = NULL;
  538.                 m_poolIdx = -1;
  539.                 m_initialized = false;
  540.         }
  541.  
  542.         // initializes the object given a skin and a stat obj
  543.         bool                 Initialize(const CAttachmentVCLOTH* pVClothAttachment);
  544.  
  545.         void                 Dettach();
  546.  
  547.         int                  GetNumLods()      { return m_numLods; }
  548.         //      bool IsSingleThreaded() { return m_bSingleThreaded; }
  549.         bool                 IsAlwaysVisible() { return m_bAlwaysVisible; }
  550.  
  551.         bool                 PrepareCloth(CSkeletonPose& skeletonPose, const Matrix34& worldMat, bool visible, int lod);
  552.         bool                 CompileCommand(SVertexSkinData& skinData, CVertexCommandBuffer& commandBuffer);
  553.  
  554.         void                 SetBlendWeight(float weight);
  555.  
  556.         bool                 NeedsDebugDraw() const { return Console::GetInst().ca_DrawCloth & 2 ? true : false; }
  557.         void                 DrawDebug(const SVertexAnimationJob* pVertexAnimation);
  558.  
  559.         void                 SetClothParams(const SVClothParams& params);
  560.         const SVClothParams& GetClothParams();
  561.         CClothSimulator&     GetSimulator() { return m_simulator; }
  562.  
  563. private:
  564.  
  565.         bool    PrepareRenderMesh(int lod);
  566.         Vector4 SkinByTriangle(int i, strided_pointer<Vec3>& pVtx, int lod);
  567.  
  568.         void    UpdateSimulation(const DualQuat* pTransformations, const uint transformationCount);
  569.         template<bool PREVIOUS_POSITIONS>
  570.         void    SkinSimulationToRenderMesh(int lod, CVertexData& vertexData, const strided_pointer<const Vec3>& pVertexPositionsPrevious);
  571.  
  572.         void    WaitForJob(bool bPrev);
  573.  
  574. private:
  575.  
  576.         CAttachmentVCLOTH* m_pVClothAttachment;
  577.         CClothSimulator    m_simulator;
  578.  
  579.         // structure containing all sim mesh related data and working buffers
  580.         SClothGeometry* m_clothGeom;
  581.         SBuffers*       m_buffers;
  582.         int             m_poolIdx;
  583.  
  584.         // used for hiding the cloth (mainly in the editor)
  585.         bool m_bHidden;
  586.  
  587.         // the number of loaded LODs
  588.         int m_numLods;
  589.  
  590.         // enables single threaded simulation updated
  591.         //      bool m_bSingleThreaded;
  592.  
  593.         // the current rotation of the character
  594.         QuatT m_charLocation;
  595.  
  596.         // for easing in and out
  597.         bool m_lastVisible;
  598.  
  599.         // flags that the cloth is always simulated
  600.         bool m_bAlwaysVisible;
  601.  
  602.         int  m_currentLod;
  603.  
  604.         // used to get the correct time from the character
  605.         CCharInstance* m_pCharInstance;
  606.  
  607.         bool           m_initialized;
  608. };
  609.  
  610. ILINE Vector4 CClothPiece::SkinByTriangle(int i, strided_pointer<Vec3>& pVtx, int lod)
  611. {
  612.         DynArray<Vector4>& tmpClothVtx = m_buffers->m_tmpClothVtx;
  613.         std::vector<Vector4>& normals = m_buffers->m_normals;
  614.         const SSkinMapEntry& skinMap = m_clothGeom->skinMap[lod][i];
  615.         int tri = skinMap.iTri;
  616.         if (tri >= 0)
  617.         {
  618.                 mesh_data* md = (mesh_data*)m_clothGeom->pPhysGeom->pGeom->GetData();
  619.                 const int i2 = skinMap.iMap;
  620.                 const int base = tri * 3;
  621.                 const int idx = md->pIndices[base + i2];
  622.                 const int idx0 = md->pIndices[base + inc_mod3[i2]];
  623.                 const int idx1 = md->pIndices[base + dec_mod3[i2]];
  624.                 const Vector4 u = tmpClothVtx[idx0] - tmpClothVtx[idx];
  625.                 const Vector4 v = tmpClothVtx[idx1] - tmpClothVtx[idx];
  626.                 const Vector4 n = (1.f - skinMap.s - skinMap.t) * normals[idx] + skinMap.s * normals[idx0] + skinMap.t * normals[idx1];
  627.                 return tmpClothVtx[idx] + skinMap.s * u + skinMap.t * v + skinMap.h * n;
  628.         }
  629.         else
  630.                 return tmpClothVtx[skinMap.iMap];
  631. }
  632.  
  633. ILINE void CClothPiece::SetBlendWeight(float weight)
  634. {
  635.         weight = max(0.f, min(1.f, weight));
  636. }
  637.  
  638. class CAttachmentVCLOTH : public IAttachmentSkin, public SAttachmentBase
  639. {
  640. public:
  641.  
  642.         CAttachmentVCLOTH()
  643.         {
  644.                 m_clothCacheKey = -1;
  645.                 for (uint32 j = 0; j < 2; ++j) m_pRenderMeshsSW[j] = NULL;
  646.                 memset(m_arrSkinningRendererData, 0, sizeof(m_arrSkinningRendererData));
  647.                 m_pRenderSkin = 0;
  648.         };
  649.  
  650.         virtual ~CAttachmentVCLOTH();
  651.  
  652.         virtual void AddRef() override
  653.         {
  654.                 ++m_nRefCounter;
  655.         }
  656.  
  657.         virtual void Release() override
  658.         {
  659.                 if (--m_nRefCounter == 0)
  660.                         delete this;
  661.         }
  662.  
  663.         virtual uint32             GetType() const override                               { return CA_VCLOTH; }
  664.         virtual uint32             SetJointName(const char* szJointName) override         { return 0; }
  665.  
  666.         virtual const char*        GetName() const override                               { return m_strSocketName; };
  667.         virtual uint32             GetNameCRC() const override                            { return m_nSocketCRC32; }
  668.         virtual uint32             ReName(const char* strSocketName, uint32 crc) override { m_strSocketName.clear(); m_strSocketName = strSocketName; m_nSocketCRC32 = crc; return 1; };
  669.  
  670.         virtual uint32             GetFlags() const override                              { return m_AttFlags | FLAGS_ATTACH_MERGED_FOR_SHADOWS; } // disable merging for vcloth shadows
  671.         virtual void               SetFlags(uint32 flags) override                        { m_AttFlags = flags; }
  672.  
  673.         void                       ReleaseRenderRemapTablePair();
  674.         void                       ReleaseSimRemapTablePair();
  675.         void                       ReleaseSoftwareRenderMeshes();
  676.  
  677.         virtual uint32             Immediate_AddBinding(IAttachmentObject* pModel, ISkin* pISkinRender = 0, uint32 nLoadingFlags = 0) override;
  678.         virtual void               Immediate_ClearBinding(uint32 nLoadingFlags = 0) override;
  679.         virtual uint32             Immediate_SwapBinding(IAttachment* pNewAttachment) override;
  680.  
  681.         uint32                     AddSimBinding(const ISkin& pISkinRender, uint32 nLoadingFlags = 0);
  682.         virtual IAttachmentObject* GetIAttachmentObject() const override { return m_pIAttachmentObject; }
  683.         virtual IAttachmentSkin*   GetIAttachmentSkin() override         { return this; }
  684.  
  685.         virtual void               HideAttachment(uint32 x) override;
  686.         virtual uint32             IsAttachmentHidden() const override             { return m_AttFlags & FLAGS_ATTACH_HIDE_MAIN_PASS; }
  687.         virtual void               HideInRecursion(uint32 x) override;
  688.         virtual uint32             IsAttachmentHiddenInRecursion() const override  { return m_AttFlags & FLAGS_ATTACH_HIDE_RECURSION; }
  689.         virtual void               HideInShadow(uint32 x) override;
  690.         virtual uint32             IsAttachmentHiddenInShadow() const override     { return m_AttFlags & FLAGS_ATTACH_HIDE_SHADOW_PASS; }
  691.  
  692.         virtual void               SetAttAbsoluteDefault(const QuatT& qt) override {};
  693.         virtual void               SetAttRelativeDefault(const QuatT& qt) override {};
  694.         virtual const QuatT& GetAttAbsoluteDefault() const override          { return g_IdentityQuatT; };
  695.         virtual const QuatT& GetAttRelativeDefault() const override          { return g_IdentityQuatT; };
  696.  
  697.         virtual const QuatT& GetAttModelRelative() const override            { return g_IdentityQuatT; };//this is relative to the animated bone
  698.         virtual const QuatTS GetAttWorldAbsolute() const override;
  699.         virtual const QuatT& GetAdditionalTransformation() const override    { return g_IdentityQuatT; }
  700.         virtual void         UpdateAttModelRelative() override;
  701.  
  702.         virtual uint32       GetJointID() const override                                                                      { return -1; };
  703.         virtual void         AlignJointAttachment() override                                                                  {};
  704.  
  705.         virtual void         SetVClothParams(const SVClothParams& params) override                                            { AddClothParams(params); }
  706.         virtual void         PostUpdateSimulationParams(bool bAttachmentSortingRequired, const char* pJointName = 0) override {};
  707.  
  708.         virtual void         Serialize(TSerialize ser) override;
  709.         virtual size_t       SizeOfThis() const override;
  710.         virtual void         GetMemoryUsage(ICrySizer* pSizer) const override;
  711.         virtual void         TriggerMeshStreaming(uint32 nDesiredRenderLOD, const SRenderingPassInfo& passInfo);
  712.  
  713.         void                 DrawAttachment(SRendParams& rParams, const SRenderingPassInfo& passInfo, const Matrix34& rWorldMat34, f32 fZoomFactor = 1);
  714.         void                 RecreateDefaultSkeleton(CCharInstance* pInstanceSkel, uint32 nLoadingFlags);
  715.         void                 UpdateRemapTable();
  716.  
  717.         void                 ComputeClothCacheKey();
  718.         uint64               GetClothCacheKey() const { return m_clothCacheKey; };
  719.         void                 AddClothParams(const SVClothParams& clothParams);
  720.         bool                 InitializeCloth();
  721.         const SVClothParams& GetClothParams();
  722.  
  723.         // Vertex Transformation
  724. public:
  725.         SSkinningData*          GetVertexTransformationData(const bool bVertexAnimation, uint8 nRenderLOD);
  726.         _smart_ptr<IRenderMesh> CreateVertexAnimationRenderMesh(uint lod, uint id);
  727.  
  728. #ifdef EDITOR_PCDEBUGCODE
  729.         void DrawWireframeStatic(const Matrix34& m34, int nLOD, uint32 color);
  730.         void SoftwareSkinningDQ_VS_Emulator(CModelMesh* pModelMesh, Matrix34 rRenderMat34, uint8 tang, uint8 binorm, uint8 norm, uint8 wire, const DualQuat* const pSkinningTransformations);
  731. #endif
  732.  
  733.         virtual IVertexAnimation* GetIVertexAnimation() override { return &m_vertexAnimation; }
  734.         virtual ISkin*            GetISkin() override            { return m_pRenderSkin; };
  735.         virtual float             GetExtent(EGeomForm eForm) override;
  736.         virtual void              GetRandomPos(PosNorm& ran, CRndGen& seed, EGeomForm eForm) const override;
  737.         virtual SMeshLodInfo      ComputeGeometricMean() const override;
  738.  
  739.         int                       GetGuid() const;
  740.  
  741.         DynArray<JointIdType>   m_arrRemapTable;    //!< maps skin's bone indices to skeleton's bone indices
  742.         DynArray<JointIdType>   m_arrSimRemapTable; //!< maps skin's bone indices to skeleton's bone indices
  743.         _smart_ptr<CSkin>       m_pRenderSkin;
  744.         _smart_ptr<CSkin>       m_pSimSkin;
  745.         _smart_ptr<IRenderMesh> m_pRenderMeshsSW[2];
  746.         string                  m_sSoftwareMeshName;
  747.         CVertexData             m_vertexData;
  748.         CVertexAnimation        m_vertexAnimation;
  749.         CClothPiece             m_clothPiece;
  750.         uint64                  m_clothCacheKey;
  751.  
  752.         // history for skinning data, needed for motion blur
  753.         struct { SSkinningData* pSkinningData; int nFrameID; } m_arrSkinningRendererData[3]; // triple buffered for motion blur
  754.  
  755. private:
  756.         // functions to keep in sync ref counts on skins and cleanup of remap tables
  757.         void ReleaseRenderSkin();
  758.         void ReleaseSimSkin();
  759. };
  760.  
downloadAttachmentVCloth.h 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