NewtonMesh* CreateQuadClothPatch(DemoEntityManager* const scene, int size_x, int size_z)
{
size_x += 1;
size_z += 1;
dAssert(size_x <= 129);
dAssert(size_z <= 129);
dFloat dimension = 0.125f;
dBigVector* const points = new dBigVector[size_x * size_z];
int* const faceIndexCount = new int[(size_x - 1) * (size_z - 1)];
int* const faceVertexIndex = new int[4 * (size_x - 1) * (size_z - 1)];
dFloat y = 0.0f;
int vertexCount = 0;
for (int i = 0; i < size_z; i++) {
dFloat z = (i - size_z / 2) * dimension;
for (int j = 0; j < size_x; j++) {
dFloat x = (j - size_x / 2) * dimension;
points[vertexCount] = dVector(x, y, z, 0.0f);
vertexCount++;
}
}
int faceCount = 0;
for (int i = 0; i < size_z - 1; i++) {
for (int j = 0; j < size_x - 1; j++) {
faceIndexCount[faceCount] = 4;
faceVertexIndex[faceCount * 4 + 0] = (i + 0) * size_x + j + 0;
faceVertexIndex[faceCount * 4 + 1] = (i + 0) * size_x + j + 1;
faceVertexIndex[faceCount * 4 + 2] = (i + 1) * size_x + j + 1;
faceVertexIndex[faceCount * 4 + 3] = (i + 1) * size_x + j + 0;
faceCount++;
}
}
dMatrix aligmentUV(dGetIdentityMatrix());
NewtonMeshVertexFormat vertexFormat;
NewtonMeshClearVertexFormat(&vertexFormat);
vertexFormat.m_faceCount = faceCount;
vertexFormat.m_faceIndexCount = faceIndexCount;
vertexFormat.m_vertex.m_data = &points[0][0];
vertexFormat.m_vertex.m_indexList = faceVertexIndex;
vertexFormat.m_vertex.m_strideInBytes = sizeof(dBigVector);
NewtonMesh* const clothPatch = NewtonMeshCreate(scene->GetNewton());
NewtonMeshBuildFromVertexListIndexList(clothPatch, &vertexFormat);
int material = LoadTexture("persianRug.tga");
NewtonMeshApplyBoxMapping(clothPatch, material, material, material, &aligmentUV[0][0]);
delete[] points;
delete[] faceIndexCount;
delete[] faceVertexIndex;
return clothPatch;
}
// create a mesh using the NewtonMesh low lever interface
static NewtonBody* CreateSimpleBox_NewtonMesh (DemoEntityManager* const scene, const dVector& origin, const dVector& scale, dFloat mass)
{
dBigVector array[8];
dBigVector scale1 (scale);
for (int i = 0; i < 8; i ++) {
dBigVector p(&BoxPoints[i * 4]);
array[i] = scale1 * p;
}
NewtonMeshVertexFormat vertexFormat;
NewtonMeshClearVertexFormat(&vertexFormat);
vertexFormat.m_faceCount = 10;
vertexFormat.m_faceIndexCount = faceIndexList;
vertexFormat.m_faceMaterial = faceMateriaIndexList;
vertexFormat.m_vertex.m_data = &array[0][0];
vertexFormat.m_vertex.m_indexList = BoxIndices;
vertexFormat.m_vertex.m_strideInBytes = sizeof (dBigVector);
vertexFormat.m_normal.m_data = normal;
vertexFormat.m_normal.m_indexList = faceNormalIndex;
vertexFormat.m_normal.m_strideInBytes = 3 * sizeof (dFloat);
// all channel are now optionals so we not longer has to pass default values
// vertexFormat.m_uv0.m_data = uv0;
// vertexFormat.m_uv0.m_indexList = uv0_indexList;
// vertexFormat.m_uv0.m_strideInBytes = 2 * sizeof (dFloat);
// now we create and empty mesh
NewtonMesh* const newtonMesh = NewtonMeshCreate(scene->GetNewton());
NewtonMeshBuildFromVertexListIndexList(newtonMesh, &vertexFormat);
// now we can use this mesh for lot of stuff, we can apply UV, we can decompose into convex,
NewtonCollision* const collision = NewtonCreateConvexHullFromMesh(scene->GetNewton(), newtonMesh, 0.001f, 0);
// for now we will simple make simple Box, make a visual Mesh
DemoMesh* const visualMesh = new DemoMesh (newtonMesh);
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const body = CreateSimpleSolid(scene, visualMesh, mass, matrix, collision, 0);
dVector veloc(1, 0, 2, 0);
NewtonBodySetVelocity(body, &veloc[0]);
visualMesh->Release();
NewtonDestroyCollision(collision);
NewtonMeshDestroy (newtonMesh);
return body;
}
static NewtonBody* CreateSimpleNewtonMeshBox (DemoEntityManager* const scene, const dVector& origin, const dVector& scale, dFloat mass)
{
// the vertex array, vertices's has for values, x, y, z, w
// w is use as a id to have multiple copy of the same very, like for example mesh that share more than two edges.
// in most case w can be set to 0.0
static dFloat64 BoxPoints[] = {
-1.0, -1.0, -1.0, 0.0,
-1.0, -1.0, 1.0, 0.0,
-1.0, 1.0, 1.0, 0.0,
-1.0, 1.0, -1.0, 0.0,
1.0, -1.0, -1.0, 0.0,
1.0, -1.0, 1.0, 0.0,
1.0, 1.0, 1.0, 0.0,
1.0, 1.0, -1.0, 0.0,
};
// the vertex index list is an array of all the face, in any order, the can be convex or concave,
// and has and variable umber of indices
static int BoxIndices[] = {
2,3,0,1, // this is quad
5,2,1, // triangle
6,2,5, // another triangle
5,1,0,4, // another quad
2,7,3, // and so on
6,7,2,
3,4,0,
7,4,3,
7,5,4,
6,5,7
};
// the number of index for each face is specified by an array of consecutive face index
static int faceIndexList [] = {4, 3, 3, 4, 3, 3, 3, 3, 3, 3};
// each face can have an arbitrary index that the application can use as a material index
// for example the index point to a texture, we can have the each face of the cube with a different texture
static int faceMateriaIndexList [] = {0, 4, 4, 2, 3, 3, 3, 3, 3, 3};
// the normal is specified per vertex and each vertex can have a unique normal or a duplicated
// for example a cube has 6 normals
static dFloat normal[] = {
1.0, 0.0, 0.0,
-1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, -1.0, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, -1.0,
};
static int faceNormalIndex [] = {
0, 0, 0, 0, // first face uses the first normal of each vertex
3, 3, 3, // second face uses the third normal
3, 3, 3, // third face uses the fifth normal
1, 1, 1, 1, // third face use the second normal
2, 2, 2, // and so on
2, 2, 2,
4, 2, 1, // a face can have per vertex normals
4, 4, 4,
5, 5, 5, // two coplanar face can even has different normals
3, 2, 0,
};
/*
// the UV are encode the same way as the vertex an the normals, a UV list and an index list
// since we do not have UV we can assign the all to zero
static dFloat uv0[] = { 0, 0};
static int uv0_indexList [] = {
0, 0, 0, 0,
0, 0, 0,
0, 0, 0,
0, 0, 0, 0,
0, 0, 0,
0, 0, 0,
0, 0, 0,
0, 0, 0,
0, 0, 0,
0, 0, 0,
};
*/
dBigVector array[8];
dBigVector scale1 (scale);
for (int i = 0; i < 8; i ++) {
dBigVector p(&BoxPoints[i * 4]);
array[i] = scale1 * p;
}
NewtonMeshVertexFormat vertexFormat;
NewtonMeshClearVertexFormat(&vertexFormat);
vertexFormat.m_faceCount = 10;
vertexFormat.m_faceIndexCount = faceIndexList;
vertexFormat.m_faceMaterial = faceMateriaIndexList;
vertexFormat.m_vertex.m_data = &array[0][0];
vertexFormat.m_vertex.m_indexList = BoxIndices;
vertexFormat.m_vertex.m_strideInBytes = sizeof (dBigVector);
vertexFormat.m_normal.m_data = normal;
vertexFormat.m_normal.m_indexList = faceNormalIndex;
vertexFormat.m_normal.m_strideInBytes = 3 * sizeof (dFloat);
// all channel are now optionals so we not longer has to pass default values
// vertexFormat.m_uv0.m_data = uv0;
// vertexFormat.m_uv0.m_indexList = uv0_indexList;
// vertexFormat.m_uv0.m_strideInBytes = 2 * sizeof (dFloat);
// now we create and empty mesh
NewtonMesh* const newtonMesh = NewtonMeshCreate(scene->GetNewton());
NewtonMeshBuildFromVertexListIndexList(newtonMesh, &vertexFormat);
// now we can use this mesh for lot of stuff, we can apply UV, we can decompose into convex,
NewtonCollision* const collision = NewtonCreateConvexHullFromMesh(scene->GetNewton(), newtonMesh, 0.001f, 0);
// for now we will simple make simple Box, make a visual Mesh
DemoMesh* const visualMesh = new DemoMesh (newtonMesh);
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const body = CreateSimpleSolid (scene, visualMesh, mass, matrix, collision, 0);
visualMesh->Release();
NewtonDestroyCollision(collision);
NewtonMeshDestroy (newtonMesh);
return body;
}
