void ConvexApproximationObject::AddPolygonFromObject(INode* const node, ObjectState* const os, NewtonMesh* const meshOut, const dMatrix& matrix)
{
BOOL needDel = FALSE;
PolyObject* const poly = GetPolyObject (os, needDel);
if (poly) {
float polygon[32][12];
memset (polygon, 0, sizeof (polygon));
MNMesh& maxMesh = poly->GetMesh();
int facesCount = maxMesh.FNum();
int vertexCount = maxMesh.VNum();
if (facesCount && vertexCount) {
for (int i = 0; i < facesCount; i ++) {
MNFace* const face = maxMesh.F(i);
for (int j = 0; j < face->deg; j ++) {
int index = face->vtx[j];
Point3 p (maxMesh.P(index));
dVector v (matrix.TransformVector(dVector (p.x, p.y, p.z, 0.0f)));
polygon[j][0] = v.m_x;
polygon[j][1] = v.m_y;
polygon[j][2] = v.m_z;
}
NewtonMeshAddFace(meshOut, face->deg, &polygon[0][0], 12 * sizeof (float), 0);
}
}
}
if (needDel) {
delete poly;
}
}
static void ExtrudeFaces (void* userData, int vertexCount, const dFloat* faceVertec, int id)
{
float OFFSET = 0.1f;
float face[32][10];
NewtonMesh* mesh = (NewtonMesh*) userData;
// calculate the face normal
dVector normal (0, 0, 0);
dVector p0 (faceVertec[0 * 3 + 0], faceVertec[0 * 3 + 1], faceVertec[0 * 3 + 2]);
dVector p1 (faceVertec[1 * 3 + 0], faceVertec[1 * 3 + 1], faceVertec[1 * 3 + 2]);
dVector e0 (p1 - p0);
for (int i = 2; i < vertexCount; i ++) {
dVector p2 (faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2]);
dVector e1 (p2 - p0);
normal += e0 * e1;
e0 = e1;
}
normal = normal.Scale (1.0f / dSqrt (normal % normal));
dVector displacemnet (normal.Scale (OFFSET));
// add the face displace by some offset
for (int i = 0; i < vertexCount; i ++) {
dVector p1 (faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2]);
p1 += displacemnet;
face[i][0] = p1.m_x;
face[i][1] = p1.m_y;
face[i][2] = p1.m_z;
face[i][3] = normal.m_x;
face[i][4] = normal.m_y;
face[i][5] = normal.m_z;
face[i][6] = 0.0f;
face[i][7] = 0.0f;
face[i][8] = 0.0f;
face[i][9] = 0.0f;
}
// add the face
NewtonMeshAddFace (mesh, vertexCount, &face[0][0], 10 * sizeof (float), id);
// now add on face walk the perimeter and add a rivet face
dVector q0 (faceVertec[(vertexCount - 1) * 3 + 0], faceVertec[(vertexCount - 1) * 3 + 1], faceVertec[(vertexCount - 1) * 3 + 2]);
q0 += displacemnet;
for (int i = 0; i < vertexCount; i ++) {
dVector q1 (faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2]);
q1 += displacemnet;
// calculate the river normal
dVector edge (q1 - q0);
dVector n (edge * normal);
n = n.Scale (1.0f / sqrtf (n % n));
// build a quad to serve a the face between the two parellel faces
face[0][0] = q0.m_x;
face[0][1] = q0.m_y;
face[0][2] = q0.m_z;
face[0][3] = n.m_x;
face[0][4] = n.m_y;
face[0][5] = n.m_z;
face[0][6] = 0.0f;
face[0][7] = 0.0f;
face[0][8] = 0.0f;
face[0][9] = 0.0f;
face[1][0] = q1.m_x;
face[1][1] = q1.m_y;
face[1][2] = q1.m_z;
face[1][3] = n.m_x;
face[1][4] = n.m_y;
face[1][5] = n.m_z;
face[1][6] = 0.0f;
face[1][7] = 0.0f;
face[1][8] = 0.0f;
face[1][9] = 0.0f;
face[2][0] = q1.m_x - displacemnet.m_x;
face[2][1] = q1.m_y - displacemnet.m_y;
face[2][2] = q1.m_z - displacemnet.m_z;
face[2][3] = n.m_x;
face[2][4] = n.m_y;
face[2][5] = n.m_z;
face[2][6] = 0.0f;
face[2][7] = 0.0f;
face[2][8] = 0.0f;
face[2][9] = 0.0f;
face[3][0] = q0.m_x - displacemnet.m_x;
face[3][1] = q0.m_y - displacemnet.m_y;
face[3][2] = q0.m_z - displacemnet.m_z;
face[3][3] = n.m_x;
face[3][4] = n.m_y;
face[3][5] = n.m_z;
face[3][6] = 0.0f;
face[3][7] = 0.0f;
face[3][8] = 0.0f;
face[3][9] = 0.0f;
// save the first point for the next rivet
q0 = q1;
// add this face to the mesh
NewtonMeshAddFace (mesh, 4, &face[0][0], 10 * sizeof (float), id);
}
}
void dMeshNodeInfo::AddPolygon (int pointsCount, const neMeshInfoFlatPoint* const points, int materialID)
{
NewtonMeshAddFace(m_mesh, pointsCount, &points[0].m_x, sizeof (neMeshInfoFlatPoint), materialID);
}
mesh::mesh(const std::string &mn, const mat4 &tf, const world &_world):
/** Don't know if world() is the best thing to pass but it works for now **/
_mesh(NewtonMeshCreate(_world))
{
Ogre::MeshPtr meshPtr;
try
{
meshPtr = Ogre::MeshPtr(Ogre::MeshManager::getSingleton().load(mn,
Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME));
}
catch(...)
{
return;
}
const Ogre::Mesh &mesh = *meshPtr;
NewtonMeshBeginFace(_mesh);
for (unsigned smi = 0; smi < mesh.getNumSubMeshes(); smi++) {
Ogre::SubMesh *subMesh = mesh.getSubMesh(smi);
Ogre::VertexData *vertexData =
(subMesh->useSharedVertices) ?
vertexData = mesh.sharedVertexData : vertexData = subMesh->vertexData;
Ogre::VertexDeclaration *vertexDecl = vertexData->vertexDeclaration;
const Ogre::VertexElement *element = vertexDecl->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vertexHVBSP =
vertexData->vertexBufferBinding->getBuffer(element->getSource());
unsigned char *vPtr = (unsigned char*)(vertexHVBSP->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
Ogre::IndexData *indexData = subMesh->indexData;
size_t numIndices = indexData->indexCount;
size_t numTris = numIndices / 3;
// get pointer!
Ogre::HardwareIndexBufferSharedPtr indexHIBSP = indexData->indexBuffer;
// 16 or 32 bit indices?
bool indicesAre32Bit = (indexHIBSP->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
unsigned long *longPtr = NULL;
unsigned short *shortPtr = NULL;
if (indicesAre32Bit)
longPtr = static_cast<unsigned long*>(
indexHIBSP->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
else
shortPtr = static_cast<unsigned short*>(
indexHIBSP->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
//now loop through the indices, getting polygon info!
int iOffset = 0;
for (size_t i = 0; i < numTris; i++) {
vec3 triVertices[3];
unsigned char *vOffset = NULL;
float *vertexPosPtr = NULL;
int idx = 0;
for (int j = 0; j < 3; j++) {
if (indicesAre32Bit)
idx = longPtr[iOffset + j];
else
idx = shortPtr[iOffset + j];
vOffset = vPtr + (idx * vertexHVBSP->getVertexSize());
element->baseVertexPointerToElement(vOffset, &vertexPosPtr);
triVertices[j].x = *vertexPosPtr; vertexPosPtr++;
triVertices[j].y = *vertexPosPtr; vertexPosPtr++;
triVertices[j].z = *vertexPosPtr; vertexPosPtr++;
triVertices[j] = tf * triVertices[j];
}
// _mesh, 3 vertices (triangle), (float = 4 bytes) * 3
// index = index of sub mesh (easy to recognize)
NewtonMeshAddFace(_mesh, 3, &triVertices[0].x, sizeof(float) * 3, smi);
iOffset += 3;
}
//unlock the buffers!
vertexHVBSP->unlock();
indexHIBSP->unlock();
}
NewtonMeshEndFace(_mesh);
}
