~ubuntu-branches/ubuntu/vivid/emscripten/vivid

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.

#include "BulletMultiThreaded/GpuSoftBodySolvers/CPU/btSoftBodySolverData.h"

#include "btSoftBodySolverBuffer_DX11.h"

#ifndef BT_ACCELERATED_SOFT_BODY_LINK_DATA_DX11_SIMDAWARE_H

#define BT_ACCELERATED_SOFT_BODY_LINK_DATA_DX11_SIMDAWARE_H

struct ID3D11Device;

struct ID3D11DeviceContext;

class btSoftBodyLinkDataDX11SIMDAware : public btSoftBodyLinkData

{

public:

bool m_onGPU;

ID3D11Device *m_d3dDevice;

ID3D11DeviceContext *m_d3dDeviceContext;

const int m_wavefrontSize;

const int m_linksPerWorkItem;

const int m_maxLinksPerWavefront;

int m_maxBatchesWithinWave;

int m_maxVerticesWithinWave;

int m_numWavefronts;

int m_maxVertex;

struct NumBatchesVerticesPair

{

int numBatches;

int numVertices;

};

// Array storing number of links in each wavefront

btAlignedObjectArray<int> m_linksPerWavefront;

btAlignedObjectArray<NumBatchesVerticesPair> m_numBatchesAndVerticesWithinWaves;

btDX11Buffer< NumBatchesVerticesPair > m_dx11NumBatchesAndVerticesWithinWaves;

// All arrays here will contain batches of m_maxLinksPerWavefront links

// ordered by wavefront.

// with either global vertex pairs or local vertex pairs

btAlignedObjectArray< int > m_wavefrontVerticesGlobalAddresses; // List of global vertices per wavefront

btDX11Buffer<int> m_dx11WavefrontVerticesGlobalAddresses;

btAlignedObjectArray< LinkNodePair > m_linkVerticesLocalAddresses; // Vertex pair for the link

btDX11Buffer<LinkNodePair> m_dx11LinkVerticesLocalAddresses;

btDX11Buffer<float> m_dx11LinkStrength;

btDX11Buffer<float> m_dx11LinksMassLSC;

btDX11Buffer<float> m_dx11LinksRestLengthSquared;

btDX11Buffer<float> m_dx11LinksRestLength;

btDX11Buffer<float> m_dx11LinksMaterialLinearStiffnessCoefficient;

struct BatchPair

{

int start;

int length;

BatchPair() :

start(0),

length(0)

{

}

BatchPair( int s, int l ) :

start( s ),

length( l )

{

}

};

/**

* Link addressing information for each cloth.

* Allows link locations to be computed independently of data batching.

btAlignedObjectArray< int > m_linkAddresses;

/**

* Start and length values for computation batches over link data.

btAlignedObjectArray< BatchPair > m_wavefrontBatchStartLengths;

//ID3D11Buffer* readBackBuffer;

btSoftBodyLinkDataDX11SIMDAware( ID3D11Device *d3dDevice, ID3D11DeviceContext *d3dDeviceContext );

100

virtual ~btSoftBodyLinkDataDX11SIMDAware();

101

102

/** Allocate enough space in all link-related arrays to fit numLinks links */

103

virtual void createLinks( int numLinks );

104

105

/** Insert the link described into the correct data structures assuming space has already been allocated by a call to createLinks */

106

virtual void setLinkAt( const LinkDescription &link, int linkIndex );

107

108

virtual bool onAccelerator();

109

110

virtual bool moveToAccelerator();

111

112

virtual bool moveFromAccelerator();

113

114

/**

115

* Generate (and later update) the batching for the entire link set.

116

* This redoes a lot of work because it batches the entire set when each cloth is inserted.

117

* In theory we could delay it until just before we need the cloth.

118

* It's a one-off overhead, though, so that is a later optimisation.

119

120

void generateBatches();

121

122

int getMaxVerticesPerWavefront()

123

{

124

return m_maxVerticesWithinWave;

125

}

126

127

int getWavefrontSize()

128

{

129

return m_wavefrontSize;

130

}

131

132

int getLinksPerWorkItem()

133

{

134

return m_linksPerWorkItem;

135

}

136

137

int getMaxLinksPerWavefront()

138

{

139

return m_maxLinksPerWavefront;

140

}

141

142

int getMaxBatchesPerWavefront()

143

{

144

return m_maxBatchesWithinWave;

145

}

146

147

int getNumWavefronts()

148

{

149

return m_numWavefronts;

150

}

151

152

NumBatchesVerticesPair getNumBatchesAndVerticesWithinWavefront( int wavefront )

153

{

154

return m_numBatchesAndVerticesWithinWaves[wavefront];

155

}

156

157

int getVertexGlobalAddresses( int vertexIndex )

158

{

159

return m_wavefrontVerticesGlobalAddresses[vertexIndex];

160

}

161

162

/**

163

* Get post-batching local addresses of the vertex pair for a link assuming all vertices used by a wavefront are loaded locally.

164

165

LinkNodePair getVertexPairLocalAddresses( int linkIndex )

166

{

167

return m_linkVerticesLocalAddresses[linkIndex];

168

}

169

170

};

171

172

173

#endif // #ifndef BT_ACCELERATED_SOFT_BODY_LINK_DATA_DX11_SIMDAWARE_H

Older »