extensions/gdx-bullet/jni/src/bullet/BulletMultiThreaded/GpuSoftBodySolvers/DX11/btSoftBodySolver_DX11.h

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library
   3 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14 */
  15
  16 #ifndef BT_ACCELERATED_SOFT_BODY_DX11_SOLVER_H
  17 #define BT_ACCELERATED_SOFT_BODY_DX11_SOLVER_H
  18
  19
  20 #include "vectormath/vmInclude.h"
  21 #include "BulletSoftBody/btSoftBodySolvers.h"
  22 #include "btSoftBodySolverVertexBuffer_DX11.h"
  23 #include "btSoftBodySolverLinkData_DX11.h"
  24 #include "btSoftBodySolverVertexData_DX11.h"
  25 #include "btSoftBodySolverTriangleData_DX11.h"
  26
  27
  28
  29 class DXFunctions
  30 {
  31 public:
  32
  33         typedef HRESULT (WINAPI * CompileFromMemoryFunc)(LPCSTR,SIZE_T,LPCSTR,const D3D10_SHADER_MACRO*,LPD3D10INCLUDE,LPCSTR,LPCSTR,UINT,UINT,ID3DX11ThreadPump*,ID3D10Blob**,ID3D10Blob**,HRESULT*);
  34
  35         ID3D11Device *           m_dx11Device;
  36         ID3D11DeviceContext* m_dx11Context;
  37         CompileFromMemoryFunc m_dx11CompileFromMemory;
  38
  39         DXFunctions(ID3D11Device *dx11Device, ID3D11DeviceContext* dx11Context, CompileFromMemoryFunc dx11CompileFromMemory) :
  40                 m_dx11Device( dx11Device ),
  41                 m_dx11Context( dx11Context ),
  42                 m_dx11CompileFromMemory( dx11CompileFromMemory )
  43         {
  44
  45         }
  46
  47         class KernelDesc
  48         {
  49         protected:
  50
  51
  52         public:
  53                 ID3D11ComputeShader* kernel;
  54                 ID3D11Buffer* constBuffer;
  55
  56                 KernelDesc()
  57                 {
  58                         kernel = 0;
  59                         constBuffer = 0;
  60                 }
  61
  62                 virtual ~KernelDesc()
  63                 {
  64                         // TODO: this should probably destroy its kernel but we need to be careful
  65                         // in case KernelDescs are copied
  66                 }
  67         };
  68
  69         /**
  70          * Compile a compute shader kernel from a string and return the appropriate KernelDesc object.
  71          */
  72         KernelDesc compileComputeShaderFromString( const char* shaderString, const char* shaderName, int constBufferSize, D3D10_SHADER_MACRO *compileMacros = 0 );
  73
  74 };
  75
  76 class btDX11SoftBodySolver : public btSoftBodySolver
  77 {
  78 protected:
  79         /**
  80          * Entry in the collision shape array.
  81          * Specifies the shape type, the transform matrix and the necessary details of the collisionShape.
  82          */
  83         struct CollisionShapeDescription
  84         {
  85                 Vectormath::Aos::Transform3 shapeTransform;
  86                 Vectormath::Aos::Vector3 linearVelocity;
  87                 Vectormath::Aos::Vector3 angularVelocity;
  88
  89                 int softBodyIdentifier;
  90                 int collisionShapeType;
  91
  92                 // Both needed for capsule
  93                 float radius;
  94                 float halfHeight;
  95
  96                 float margin;
  97                 float friction;
  98
  99                 CollisionShapeDescription()
 100                 {
 101                         collisionShapeType = 0;
 102                         margin = 0;
 103                         friction = 0;
 104                 }
 105         };
 106
 107         struct UIntVector3
 108         {
 109                 UIntVector3()
 110                 {
 111                         x = 0;
 112                         y = 0;
 113                         z = 0;
 114                         _padding = 0;
 115                 }
 116
 117                 UIntVector3( unsigned int x_, unsigned int y_, unsigned int z_ )
 118                 {
 119                         x = x_;
 120                         y = y_;
 121                         z = z_;
 122                         _padding = 0;
 123                 }
 124
 125                 unsigned int x;
 126                 unsigned int y;
 127                 unsigned int z;
 128                 unsigned int _padding;
 129         };
 130
 131
 132
 133 public:
 134         /**
 135          * SoftBody class to maintain information about a soft body instance
 136          * within a solver.
 137          * This data addresses the main solver arrays.
 138          */
 139         class btAcceleratedSoftBodyInterface
 140         {
 141         protected:
 142                 /** Current number of vertices that are part of this cloth */
 143                 int m_numVertices;
 144                 /** Maximum number of vertices allocated to be part of this cloth */
 145                 int m_maxVertices;
 146                 /** Current number of triangles that are part of this cloth */
 147                 int m_numTriangles;
 148                 /** Maximum number of triangles allocated to be part of this cloth */
 149                 int m_maxTriangles;
 150                 /** Index of first vertex in the world allocated to this cloth */
 151                 int m_firstVertex;
 152                 /** Index of first triangle in the world allocated to this cloth */
 153                 int m_firstTriangle;
 154                 /** Index of first link in the world allocated to this cloth */
 155                 int m_firstLink;
 156                 /** Maximum number of links allocated to this cloth */
 157                 int m_maxLinks;
 158                 /** Current number of links allocated to this cloth */
 159                 int m_numLinks;
 160
 161                 /** The actual soft body this data represents */
 162                 btSoftBody *m_softBody;
 163
 164
 165         public:
 166                 btAcceleratedSoftBodyInterface( btSoftBody *softBody ) :
 167                   m_softBody( softBody )
 168                 {
 169                         m_numVertices = 0;
 170                         m_maxVertices = 0;
 171                         m_numTriangles = 0;
 172                         m_maxTriangles = 0;
 173                         m_firstVertex = 0;
 174                         m_firstTriangle = 0;
 175                         m_firstLink = 0;
 176                         m_maxLinks = 0;
 177                         m_numLinks = 0;
 178                 }
 179                 int getNumVertices() const
 180                 {
 181                         return m_numVertices;
 182                 }
 183
 184                 int getNumTriangles() const
 185                 {
 186                         return m_numTriangles;
 187                 }
 188
 189                 int getMaxVertices() const
 190                 {
 191                         return m_maxVertices;
 192                 }
 193
 194                 int getMaxTriangles() const
 195                 {
 196                         return m_maxTriangles;
 197                 }
 198
 199                 int getFirstVertex() const
 200                 {
 201                         return m_firstVertex;
 202                 }
 203
 204                 int getFirstTriangle() const
 205                 {
 206                         return m_firstTriangle;
 207                 }
 208
 209
 210                 /**
 211                  * Update the bounds in the btSoftBody object
 212                  */
 213                 void updateBounds( const btVector3 &lowerBound, const btVector3 &upperBound );
 214
 215
 216                 // TODO: All of these set functions will have to do checks and
 217                 // update the world because restructuring of the arrays will be necessary
 218                 // Reasonable use of "friend"?
 219                 void setNumVertices( int numVertices )
 220                 {
 221                         m_numVertices = numVertices;
 222                 }
 223
 224                 void setNumTriangles( int numTriangles )
 225                 {
 226                         m_numTriangles = numTriangles;
 227                 }
 228
 229                 void setMaxVertices( int maxVertices )
 230                 {
 231                         m_maxVertices = maxVertices;
 232                 }
 233
 234                 void setMaxTriangles( int maxTriangles )
 235                 {
 236                         m_maxTriangles = maxTriangles;
 237                 }
 238
 239                 void setFirstVertex( int firstVertex )
 240                 {
 241                         m_firstVertex = firstVertex;
 242                 }
 243
 244                 void setFirstTriangle( int firstTriangle )
 245                 {
 246                         m_firstTriangle = firstTriangle;
 247                 }
 248
 249                 void setMaxLinks( int maxLinks )
 250                 {
 251                         m_maxLinks = maxLinks;
 252                 }
 253
 254                 void setNumLinks( int numLinks )
 255                 {
 256                         m_numLinks = numLinks;
 257                 }
 258
 259                 void setFirstLink( int firstLink )
 260                 {
 261                         m_firstLink = firstLink;
 262                 }
 263
 264                 int getMaxLinks()
 265                 {
 266                         return m_maxLinks;
 267                 }
 268
 269                 int getNumLinks()
 270                 {
 271                         return m_numLinks;
 272                 }
 273
 274                 int getFirstLink()
 275                 {
 276                         return m_firstLink;
 277                 }
 278
 279                 btSoftBody* getSoftBody()
 280                 {
 281                         return m_softBody;
 282                 }
 283
 284         };
 285
 286
 287         struct CollisionObjectIndices
 288         {
 289                 CollisionObjectIndices( int f, int e )
 290                 {
 291                         firstObject = f;
 292                         endObject = e;
 293                 }
 294
 295                 int firstObject;
 296                 int endObject;
 297         };
 298
 299
 300
 301
 302
 303         struct PrepareLinksCB
 304         {
 305                 int numLinks;
 306                 int padding0;
 307                 int padding1;
 308                 int padding2;
 309         };
 310
 311         struct SolvePositionsFromLinksKernelCB
 312         {
 313                 int startLink;
 314                 int numLinks;
 315                 float kst;
 316                 float ti;
 317         };
 318
 319         struct IntegrateCB
 320         {
 321                 int numNodes;
 322                 float solverdt;
 323                 int padding1;
 324                 int padding2;
 325         };
 326
 327         struct UpdatePositionsFromVelocitiesCB
 328         {
 329                 int numNodes;
 330                 float solverSDT;
 331                 int padding1;
 332                 int padding2;
 333         };
 334
 335         struct UpdateVelocitiesFromPositionsWithoutVelocitiesCB
 336         {
 337                 int numNodes;
 338                 float isolverdt;
 339                 int padding1;
 340                 int padding2;
 341         };
 342
 343         struct UpdateVelocitiesFromPositionsWithVelocitiesCB
 344         {
 345                 int numNodes;
 346                 float isolverdt;
 347                 int padding1;
 348                 int padding2;
 349         };
 350
 351         struct UpdateSoftBodiesCB
 352         {
 353                 int numNodes;
 354                 int startFace;
 355                 int numFaces;
 356                 float epsilon;
 357         };
 358
 359
 360         struct ApplyForcesCB
 361         {
 362                 unsigned int numNodes;
 363                 float solverdt;
 364                 float epsilon;
 365                 int padding3;
 366         };
 367
 368         struct AddVelocityCB
 369         {
 370                 int startNode;
 371                 int lastNode;
 372                 float velocityX;
 373                 float velocityY;
 374                 float velocityZ;
 375                 int padding1;
 376                 int padding2;
 377                 int padding3;
 378         };
 379
 380         struct VSolveLinksCB
 381         {
 382                 int startLink;
 383                 int numLinks;
 384                 float kst;
 385                 int padding;
 386         };
 387
 388         struct ComputeBoundsCB
 389         {
 390                 int numNodes;
 391                 int numSoftBodies;
 392                 int padding1;
 393                 int padding2;
 394         };
 395
 396         struct SolveCollisionsAndUpdateVelocitiesCB
 397         {
 398                 unsigned int numNodes;
 399                 float isolverdt;
 400                 int padding0;
 401                 int padding1;
 402         };
 403
 404
 405
 406
 407 protected:
 408         ID3D11Device *           m_dx11Device;
 409         ID3D11DeviceContext* m_dx11Context;
 410
 411         DXFunctions dxFunctions;
 412 public:
 413         /** Link data for all cloths. Note that this will be sorted batch-wise for efficient computation and m_linkAddresses will maintain the addressing. */
 414         btSoftBodyLinkDataDX11 m_linkData;
 415         btSoftBodyVertexDataDX11 m_vertexData;
 416         btSoftBodyTriangleDataDX11 m_triangleData;
 417
 418 protected:
 419
 420         /** Variable to define whether we need to update solver constants on the next iteration */
 421         bool m_updateSolverConstants;
 422
 423         bool m_shadersInitialized;
 424
 425         /**
 426          * Cloths owned by this solver.
 427          * Only our cloths are in this array.
 428          */
 429         btAlignedObjectArray< btAcceleratedSoftBodyInterface * > m_softBodySet;
 430
 431         /** Acceleration value to be applied to all non-static vertices in the solver.
 432          * Index n is cloth n, array sized by number of cloths in the world not the solver.
 433          */
 434         btAlignedObjectArray< Vectormath::Aos::Vector3 >        m_perClothAcceleration;
 435         btDX11Buffer<Vectormath::Aos::Vector3>                          m_dx11PerClothAcceleration;
 436
 437         /** Wind velocity to be applied normal to all non-static vertices in the solver.
 438          * Index n is cloth n, array sized by number of cloths in the world not the solver.
 439          */
 440         btAlignedObjectArray< Vectormath::Aos::Vector3 >        m_perClothWindVelocity;
 441         btDX11Buffer<Vectormath::Aos::Vector3>                          m_dx11PerClothWindVelocity;
 442
 443         /** Velocity damping factor */
 444         btAlignedObjectArray< float >                                           m_perClothDampingFactor;
 445         btDX11Buffer<float>                                                                     m_dx11PerClothDampingFactor;
 446
 447         /** Velocity correction coefficient */
 448         btAlignedObjectArray< float >                                           m_perClothVelocityCorrectionCoefficient;
 449         btDX11Buffer<float>                                                                     m_dx11PerClothVelocityCorrectionCoefficient;
 450
 451         /** Lift parameter for wind effect on cloth. */
 452         btAlignedObjectArray< float >                                           m_perClothLiftFactor;
 453         btDX11Buffer<float>                                                                     m_dx11PerClothLiftFactor;
 454
 455         /** Drag parameter for wind effect on cloth. */
 456         btAlignedObjectArray< float >                                           m_perClothDragFactor;
 457         btDX11Buffer<float>                                                                     m_dx11PerClothDragFactor;
 458
 459         /** Density of the medium in which each cloth sits */
 460         btAlignedObjectArray< float >                                           m_perClothMediumDensity;
 461         btDX11Buffer<float>                                                                     m_dx11PerClothMediumDensity;
 462
 463
 464         /**
 465          * Collision shape details: pair of index of first collision shape for the cloth and number of collision objects.
 466          */
 467         btAlignedObjectArray< CollisionObjectIndices >          m_perClothCollisionObjects;
 468         btDX11Buffer<CollisionObjectIndices>                            m_dx11PerClothCollisionObjects;
 469
 470         /**
 471          * Collision shapes being passed across to the cloths in this solver.
 472          */
 473         btAlignedObjectArray< CollisionShapeDescription >       m_collisionObjectDetails;
 474         btDX11Buffer< CollisionShapeDescription >                       m_dx11CollisionObjectDetails;
 475
 476         /**
 477          * Minimum bounds for each cloth.
 478          * Updated by GPU and returned for use by broad phase.
 479          * These are int vectors as a reminder that they store the int representation of a float, not a float.
 480          * Bit 31 is inverted - is floats are stored with int-sortable values.
 481          */
 482         btAlignedObjectArray< UIntVector3 >     m_perClothMinBounds;
 483         btDX11Buffer< UIntVector3 >                     m_dx11PerClothMinBounds;
 484
 485         /**
 486          * Maximum bounds for each cloth.
 487          * Updated by GPU and returned for use by broad phase.
 488          * These are int vectors as a reminder that they store the int representation of a float, not a float.
 489          * Bit 31 is inverted - is floats are stored with int-sortable values.
 490          */
 491         btAlignedObjectArray< UIntVector3 >     m_perClothMaxBounds;
 492         btDX11Buffer< UIntVector3 >                     m_dx11PerClothMaxBounds;
 493
 494
 495         /**
 496          * Friction coefficient for each cloth
 497          */
 498         btAlignedObjectArray< float >   m_perClothFriction;
 499         btDX11Buffer< float >                   m_dx11PerClothFriction;
 500
 501         DXFunctions::KernelDesc         prepareLinksKernel;
 502         DXFunctions::KernelDesc         solvePositionsFromLinksKernel;
 503         DXFunctions::KernelDesc         vSolveLinksKernel;
 504         DXFunctions::KernelDesc         integrateKernel;
 505         DXFunctions::KernelDesc         addVelocityKernel;
 506         DXFunctions::KernelDesc         updatePositionsFromVelocitiesKernel;
 507         DXFunctions::KernelDesc         updateVelocitiesFromPositionsWithoutVelocitiesKernel;
 508         DXFunctions::KernelDesc         updateVelocitiesFromPositionsWithVelocitiesKernel;
 509         DXFunctions::KernelDesc         solveCollisionsAndUpdateVelocitiesKernel;
 510         DXFunctions::KernelDesc         resetNormalsAndAreasKernel;
 511         DXFunctions::KernelDesc         normalizeNormalsAndAreasKernel;
 512         DXFunctions::KernelDesc         computeBoundsKernel;
 513         DXFunctions::KernelDesc         updateSoftBodiesKernel;
 514
 515         DXFunctions::KernelDesc         applyForcesKernel;
 516
 517         bool    m_enableUpdateBounds;
 518
 519         /**
 520          * Integrate motion on the solver.
 521          */
 522         virtual void integrate( float solverdt );
 523         float computeTriangleArea(
 524                 const Vectormath::Aos::Point3 &vertex0,
 525                 const Vectormath::Aos::Point3 &vertex1,
 526                 const Vectormath::Aos::Point3 &vertex2 );
 527
 528
 529         virtual bool buildShaders();
 530
 531         void resetNormalsAndAreas( int numVertices );
 532
 533         void normalizeNormalsAndAreas( int numVertices );
 534
 535         void executeUpdateSoftBodies( int firstTriangle, int numTriangles );
 536
 537         void prepareCollisionConstraints();
 538
 539         Vectormath::Aos::Vector3 ProjectOnAxis( const Vectormath::Aos::Vector3 &v, const Vectormath::Aos::Vector3 &a );
 540
 541         void ApplyClampedForce( float solverdt, const Vectormath::Aos::Vector3 &force, const Vectormath::Aos::Vector3 &vertexVelocity, float inverseMass, Vectormath::Aos::Vector3 &vertexForce );
 542
 543         virtual void applyForces( float solverdt );
 544
 545         virtual void updateConstants( float timeStep );
 546         int findSoftBodyIndex( const btSoftBody* const softBody );
 547
 548         //////////////////////////////////////
 549         // Kernel dispatches
 550         virtual void prepareLinks();
 551
 552         void updatePositionsFromVelocities( float solverdt );
 553         void solveLinksForPosition( int startLink, int numLinks, float kst, float ti );
 554         void solveLinksForVelocity( int startLink, int numLinks, float kst );
 555
 556         void updateVelocitiesFromPositionsWithVelocities( float isolverdt );
 557         void updateVelocitiesFromPositionsWithoutVelocities( float isolverdt );
 558         void computeBounds( );
 559         void solveCollisionsAndUpdateVelocities( float isolverdt );
 560
 561         // End kernel dispatches
 562         /////////////////////////////////////
 563
 564         void updateBounds();
 565
 566
 567         void releaseKernels();
 568
 569 public:
 570         btDX11SoftBodySolver(ID3D11Device * dx11Device, ID3D11DeviceContext* dx11Context, DXFunctions::CompileFromMemoryFunc dx11CompileFromMemory = &D3DX11CompileFromMemory);
 571
 572         virtual ~btDX11SoftBodySolver();
 573
 574
 575         virtual SolverTypes getSolverType() const
 576         {
 577                 return DX_SOLVER;
 578         }
 579
 580         void    setEnableUpdateBounds(bool enableBounds)
 581         {
 582                 m_enableUpdateBounds = enableBounds;
 583         }
 584         bool getEnableUpdateBounds() const
 585         {
 586                 return  m_enableUpdateBounds;
 587         }
 588
 589
 590
 591         virtual btSoftBodyLinkData &getLinkData();
 592
 593         virtual btSoftBodyVertexData &getVertexData();
 594
 595         virtual btSoftBodyTriangleData &getTriangleData();
 596
 597
 598
 599
 600
 601         btAcceleratedSoftBodyInterface *findSoftBodyInterface( const btSoftBody* const softBody );
 602         const btAcceleratedSoftBodyInterface * const findSoftBodyInterface( const btSoftBody* const softBody ) const;
 603
 604         virtual bool checkInitialized();
 605
 606         virtual void updateSoftBodies( );
 607
 608         virtual void optimize( btAlignedObjectArray< btSoftBody * > &softBodies , bool forceUpdate=false);
 609
 610         virtual void copyBackToSoftBodies(bool bMove = true);
 611
 612         virtual void solveConstraints( float solverdt );
 613
 614         virtual void predictMotion( float solverdt );
 615
 616
 617         virtual void processCollision( btSoftBody *, const btCollisionObjectWrapper* );
 618
 619         virtual void processCollision( btSoftBody*, btSoftBody* );
 620
 621 };
 622
 623
 624
 625 /**
 626  * Class to manage movement of data from a solver to a given target.
 627  * This version is the DX to CPU version.
 628  */
 629 class btSoftBodySolverOutputDXtoCPU : public btSoftBodySolverOutput
 630 {
 631 protected:
 632
 633 public:
 634         btSoftBodySolverOutputDXtoCPU()
 635         {
 636         }
 637
 638         /** Output current computed vertex data to the vertex buffers for all cloths in the solver. */
 639         virtual void copySoftBodyToVertexBuffer( const btSoftBody * const softBody, btVertexBufferDescriptor *vertexBuffer );
 640 };
 641
 642 /**
 643  * Class to manage movement of data from a solver to a given target.
 644  * This version is the DX to DX version and subclasses DX to CPU so that it works for that too.
 645  */
 646 class btSoftBodySolverOutputDXtoDX : public btSoftBodySolverOutputDXtoCPU
 647 {
 648 protected:
 649         struct OutputToVertexArrayCB
 650         {
 651                 int startNode;
 652                 int numNodes;
 653                 int positionOffset;
 654                 int positionStride;
 655
 656                 int normalOffset;
 657                 int normalStride;
 658                 int padding1;
 659                 int padding2;
 660         };
 661
 662         DXFunctions dxFunctions;
 663         DXFunctions::KernelDesc outputToVertexArrayWithNormalsKernel;
 664         DXFunctions::KernelDesc outputToVertexArrayWithoutNormalsKernel;
 665
 666
 667         bool m_shadersInitialized;
 668
 669         bool checkInitialized();
 670         bool buildShaders();
 671         void releaseKernels();
 672
 673 public:
 674         btSoftBodySolverOutputDXtoDX(ID3D11Device *dx11Device, ID3D11DeviceContext* dx11Context, DXFunctions::CompileFromMemoryFunc dx11CompileFromMemory = &D3DX11CompileFromMemory) :
 675           dxFunctions( dx11Device, dx11Context, dx11CompileFromMemory )
 676         {
 677                 m_shadersInitialized = false;
 678         }
 679
 680         ~btSoftBodySolverOutputDXtoDX()
 681         {
 682                 releaseKernels();
 683         }
 684
 685         /** Output current computed vertex data to the vertex buffers for all cloths in the solver. */
 686         virtual void copySoftBodyToVertexBuffer( const btSoftBody * const softBody, btVertexBufferDescriptor *vertexBuffer );
 687 };
 688
 689 #endif // #ifndef BT_ACCELERATED_SOFT_BODY_DX11_SOLVER_H
 690
 691