btSoftBodySolver_OpenCL.h

Go to the documentation of this file.

/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, 
including commercial applications, and to alter it and redistribute it freely, 
subject to the following restrictions:

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.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#ifndef BT_SOFT_BODY_SOLVER_OPENCL_H
#define BT_SOFT_BODY_SOLVER_OPENCL_H

#include "stddef.h" //for size_t
#include "vectormath/vmInclude.h"

#include "BulletSoftBody/btSoftBodySolvers.h"
#include "BulletSoftBody/btSoftBody.h"
#include "btSoftBodySolverBuffer_OpenCL.h"
#include "btSoftBodySolverLinkData_OpenCL.h"
#include "btSoftBodySolverVertexData_OpenCL.h"
#include "btSoftBodySolverTriangleData_OpenCL.h"

class CLFunctions
{
protected:
        cl_command_queue        m_cqCommandQue;
        cl_context                      m_cxMainContext;

        int     m_kernelCompilationFailures;


public:
        CLFunctions(cl_command_queue cqCommandQue, cl_context cxMainContext) :
                m_cqCommandQue( cqCommandQue ),
                m_cxMainContext( cxMainContext ),
                m_kernelCompilationFailures(0)
        {
        }

        int getKernelCompilationFailures() const
        {
                return m_kernelCompilationFailures;
        }

        virtual cl_kernel compileCLKernelFromString( const char* kernelSource, const char* kernelName, const char* additionalMacros, const char* srcFileNameForCaching);

        void    clearKernelCompilationFailures()
        {
                m_kernelCompilationFailures=0;
        }
};

struct CollisionShapeDescription
{
        Vectormath::Aos::Transform3 shapeTransform;
        Vectormath::Aos::Vector3 linearVelocity;
        Vectormath::Aos::Vector3 angularVelocity;

        int softBodyIdentifier;
        int collisionShapeType;

        // Both needed for capsule
        float radius;
        float halfHeight;
        int upAxis;
        
        float margin;
        float friction;

        CollisionShapeDescription()
        {
                collisionShapeType = 0;
                margin = 0;
                friction = 0;
        }
};

class btOpenCLAcceleratedSoftBodyInterface
{
protected:
        int m_numVertices;
        int m_maxVertices;
        int m_numTriangles;
        int m_maxTriangles;
        int m_firstVertex;
        int m_firstTriangle;
        int m_firstLink;
        int m_maxLinks;
        int m_numLinks;

        btSoftBody *m_softBody;


public:
        btOpenCLAcceleratedSoftBodyInterface( btSoftBody *softBody ) :
          m_softBody( softBody )
        {
                m_numVertices = 0;
                m_maxVertices = 0;
                m_numTriangles = 0;
                m_maxTriangles = 0;
                m_firstVertex = 0;
                m_firstTriangle = 0;
                m_firstLink = 0;
                m_maxLinks = 0;
                m_numLinks = 0;
        }
        int getNumVertices()
        {
                return m_numVertices;
        }

        int getNumTriangles()
        {
                return m_numTriangles;
        }

        int getMaxVertices()
        {
                return m_maxVertices;
        }

        int getMaxTriangles()
        {
                return m_maxTriangles;
        }

        int getFirstVertex()
        {
                return m_firstVertex;
        }

        int getFirstTriangle()
        {
                return m_firstTriangle;
        }
        
        void updateBounds( const btVector3 &lowerBound, const btVector3 &upperBound );

        // TODO: All of these set functions will have to do checks and
        // update the world because restructuring of the arrays will be necessary
        // Reasonable use of "friend"?
        void setNumVertices( int numVertices )
        {
                m_numVertices = numVertices;
        }       

        void setNumTriangles( int numTriangles )
        {
                m_numTriangles = numTriangles;
        }

        void setMaxVertices( int maxVertices )
        {
                m_maxVertices = maxVertices;
        }

        void setMaxTriangles( int maxTriangles )
        {
                m_maxTriangles = maxTriangles;
        }

        void setFirstVertex( int firstVertex )
        {
                m_firstVertex = firstVertex;
        }

        void setFirstTriangle( int firstTriangle )
        {
                m_firstTriangle = firstTriangle;
        }

        void setMaxLinks( int maxLinks )
        {
                m_maxLinks = maxLinks;
        }

        void setNumLinks( int numLinks )
        {
                m_numLinks = numLinks;
        }

        void setFirstLink( int firstLink )
        {
                m_firstLink = firstLink;
        }

        int getMaxLinks()
        {
                return m_maxLinks;
        }

        int getNumLinks()
        {
                return m_numLinks;
        }

        int getFirstLink()
        {
                return m_firstLink;
        }

        btSoftBody* getSoftBody()
        {
                return m_softBody;
        }

};



class btOpenCLSoftBodySolver : public btSoftBodySolver
{
public:
        

        struct UIntVector3
        {
                UIntVector3()
                {
                        x = 0;
                        y = 0;
                        z = 0;
                        _padding = 0;
                }
                
                UIntVector3( unsigned int x_, unsigned int y_, unsigned int z_ )
                {
                        x = x_;
                        y = y_;
                        z = z_;
                        _padding = 0;
                }
                        
                unsigned int x;
                unsigned int y;
                unsigned int z;
                unsigned int _padding;
        };

        struct CollisionObjectIndices
        {
                CollisionObjectIndices( int f, int e )
                {
                        firstObject = f;
                        endObject = e;
                }

                int firstObject;
                int endObject;
        };

        btSoftBodyLinkDataOpenCL m_linkData;
        btSoftBodyVertexDataOpenCL m_vertexData;
        btSoftBodyTriangleDataOpenCL m_triangleData;

protected:

        CLFunctions m_defaultCLFunctions;
        CLFunctions* m_currentCLFunctions;

        bool m_updateSolverConstants;

        bool m_shadersInitialized;

        btAlignedObjectArray< btOpenCLAcceleratedSoftBodyInterface * > m_softBodySet;

        btAlignedObjectArray< Vectormath::Aos::Vector3 >        m_perClothAcceleration;
        btOpenCLBuffer<Vectormath::Aos::Vector3>                        m_clPerClothAcceleration;

        btAlignedObjectArray< Vectormath::Aos::Vector3 >        m_perClothWindVelocity;
        btOpenCLBuffer<Vectormath::Aos::Vector3>                        m_clPerClothWindVelocity;

        btAlignedObjectArray< float >                                           m_perClothDampingFactor;
        btOpenCLBuffer<float>                                                           m_clPerClothDampingFactor;

        btAlignedObjectArray< float >                                           m_perClothVelocityCorrectionCoefficient;
        btOpenCLBuffer<float>                                                           m_clPerClothVelocityCorrectionCoefficient;

        btAlignedObjectArray< float >                                           m_perClothLiftFactor;
        btOpenCLBuffer<float>                                                           m_clPerClothLiftFactor;
        
        btAlignedObjectArray< float >                                           m_perClothDragFactor;
        btOpenCLBuffer<float>                                                           m_clPerClothDragFactor;

        btAlignedObjectArray< float >                                           m_perClothMediumDensity;
        btOpenCLBuffer<float>                                                           m_clPerClothMediumDensity;

        btAlignedObjectArray< CollisionObjectIndices >          m_perClothCollisionObjects;
        btOpenCLBuffer<CollisionObjectIndices>                          m_clPerClothCollisionObjects;

        btAlignedObjectArray< CollisionShapeDescription >       m_collisionObjectDetails;
        btOpenCLBuffer< CollisionShapeDescription >                     m_clCollisionObjectDetails;


        
        btAlignedObjectArray< float >   m_perClothFriction;
        btOpenCLBuffer< float >                 m_clPerClothFriction;

        // anchor node info
        struct AnchorNodeInfoCL
        {
                int clVertexIndex;
                btSoftBody::Node* pNode;
        };

        btAlignedObjectArray<AnchorNodeInfoCL> m_anchorNodeInfoArray;
        btAlignedObjectArray<Vectormath::Aos::Point3> m_anchorPosition;
        btOpenCLBuffer<Vectormath::Aos::Point3>           m_clAnchorPosition;
        btAlignedObjectArray<int> m_anchorIndex;
        btOpenCLBuffer<int>               m_clAnchorIndex;

        bool m_bUpdateAnchoredNodePos;

        cl_kernel               m_prepareLinksKernel;
        cl_kernel               m_solvePositionsFromLinksKernel;
        cl_kernel               m_updateConstantsKernel;
        cl_kernel               m_integrateKernel;
        cl_kernel               m_addVelocityKernel;
        cl_kernel               m_updatePositionsFromVelocitiesKernel;
        cl_kernel               m_updateVelocitiesFromPositionsWithoutVelocitiesKernel;
        cl_kernel               m_updateVelocitiesFromPositionsWithVelocitiesKernel;
        cl_kernel               m_vSolveLinksKernel;
        cl_kernel               m_solveCollisionsAndUpdateVelocitiesKernel;
        cl_kernel               m_resetNormalsAndAreasKernel;
        cl_kernel               m_normalizeNormalsAndAreasKernel;
        cl_kernel               m_updateSoftBodiesKernel;

        cl_kernel               m_outputToVertexArrayKernel;
        cl_kernel               m_applyForcesKernel;
        cl_kernel       m_updateFixedVertexPositionsKernel;     

        cl_command_queue        m_cqCommandQue;
        cl_context                      m_cxMainContext;
        
        size_t                          m_defaultWorkGroupSize;


        virtual bool buildShaders();

        void resetNormalsAndAreas( int numVertices );

        void normalizeNormalsAndAreas( int numVertices );

        void executeUpdateSoftBodies( int firstTriangle, int numTriangles );

        void prepareCollisionConstraints();
        
        Vectormath::Aos::Vector3 ProjectOnAxis( const Vectormath::Aos::Vector3 &v, const Vectormath::Aos::Vector3 &a );

        void ApplyClampedForce( float solverdt, const Vectormath::Aos::Vector3 &force, const Vectormath::Aos::Vector3 &vertexVelocity, float inverseMass, Vectormath::Aos::Vector3 &vertexForce );
        

        int findSoftBodyIndex( const btSoftBody* const softBody );

        virtual void applyForces( float solverdt );

        void updateFixedVertexPositions();

        virtual void integrate( float solverdt );

        virtual void updateConstants( float timeStep );

        float computeTriangleArea( 
                const Vectormath::Aos::Point3 &vertex0,
                const Vectormath::Aos::Point3 &vertex1,
                const Vectormath::Aos::Point3 &vertex2 );


        // Kernel dispatches
        void prepareLinks();

        void solveLinksForVelocity( int startLink, int numLinks, float kst );

        void updatePositionsFromVelocities( float solverdt );

        virtual void solveLinksForPosition( int startLink, int numLinks, float kst, float ti );
        
        void updateVelocitiesFromPositionsWithVelocities( float isolverdt );

        void updateVelocitiesFromPositionsWithoutVelocities( float isolverdt );
        virtual void solveCollisionsAndUpdateVelocities( float isolverdt );

        // End kernel dispatches
        
        void updateBounds();

        void releaseKernels();

public:
        btOpenCLSoftBodySolver(cl_command_queue queue,cl_context        ctx, bool bUpdateAchchoredNodePos = false);

        virtual ~btOpenCLSoftBodySolver();


        
        btOpenCLAcceleratedSoftBodyInterface *findSoftBodyInterface( const btSoftBody* const softBody );

        virtual btSoftBodyLinkData &getLinkData();

        virtual btSoftBodyVertexData &getVertexData();

        virtual btSoftBodyTriangleData &getTriangleData();

        virtual SolverTypes getSolverType() const
        {
                return CL_SOLVER;
        }


        virtual bool checkInitialized();

        virtual void updateSoftBodies( );

        virtual void optimize( btAlignedObjectArray< btSoftBody * > &softBodies , bool forceUpdate=false);

        virtual void copyBackToSoftBodies(bool bMove = true);

        virtual void solveConstraints( float solverdt );

        virtual void predictMotion( float solverdt );

        virtual void processCollision( btSoftBody *, const btCollisionObjectWrapper* );

        virtual void processCollision( btSoftBody*, btSoftBody* );

        virtual void    setDefaultWorkgroupSize(size_t workGroupSize)
        {
                m_defaultWorkGroupSize = workGroupSize;
        }
        virtual size_t  getDefaultWorkGroupSize() const
        {
                return m_defaultWorkGroupSize;
        }

        void    setCLFunctions(CLFunctions* funcs)
        {
                if (funcs)
                        m_currentCLFunctions = funcs;
                else
                        m_currentCLFunctions  = &m_defaultCLFunctions;
        }

}; // btOpenCLSoftBodySolver


class btSoftBodySolverOutputCLtoCPU : public btSoftBodySolverOutput
{
protected:

public:
        btSoftBodySolverOutputCLtoCPU()
        {
        }

        virtual void copySoftBodyToVertexBuffer( const btSoftBody * const softBody, btVertexBufferDescriptor *vertexBuffer );
};



#endif // #ifndef BT_SOFT_BODY_SOLVER_OPENCL_H