You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

223 lines
6.9 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "plMaxMeshExtractor.h"
#include "Max.h"
#include "plMaxNode.h"
#include "dummy.h"
static Mesh* ExtractMesh(INode* pNode, TriObject** ppDeleteMe)
{
Object *obj = pNode->EvalWorldState(0).obj;
Mesh *pRetMesh = nil;
if( obj ) {
if( obj->CanConvertToType(triObjectClassID) ) {
// Convert to triangle object
TriObject *tri = (TriObject*)obj->ConvertToType(0, triObjectClassID);
if (tri != obj) *ppDeleteMe = tri; // if Convert allocated, pass back so caller can delete.
if( tri ) {
Mesh *pTMesh = &tri->mesh;
if( pTMesh->getNumFaces() ) {
pRetMesh = pTMesh;
}
}
}
}
return pRetMesh;
}
// Return the two points defining the bounding box for the given vertices.
static void MeshMinMax(hsPoint3& min, hsPoint3& max, int numVerts, hsPoint3* pVerts)
{
for (int i = 0; i < numVerts; i++)
{
hsPoint3* vert = &pVerts[i];
min.fX = hsMinimum(vert->fX, min.fX);
min.fY = hsMinimum(vert->fY, min.fY);
min.fZ = hsMinimum(vert->fZ, min.fZ);
max.fX = hsMaximum(vert->fX, max.fX);
max.fY = hsMaximum(vert->fY, max.fY);
max.fZ = hsMaximum(vert->fZ, max.fZ);
}
}
static bool MakeNormalMesh(plMaxNode *node, plMaxMeshExtractor::NeutralMesh& mesh, Matrix3* w2l)
{
TriObject *pDeleteMe = nil;
Mesh *pMesh = ExtractMesh(node, &pDeleteMe); // allocates *sometimes*; check pDeleteMe
if (!pMesh)
return false;
Matrix3 fullTM = node->GetObjectTM(0);
int parity = fullTM.Parity();
mesh.fNumVerts = pMesh->numVerts;
mesh.fVerts = TRACKED_NEW hsPoint3[mesh.fNumVerts];
for (int i = 0; i < mesh.fNumVerts; i++)
{
// convert the vertex to global coordinates
Point3 newVert = fullTM * pMesh->verts[i];
// convert the vertex to the new (requested) coordinate system
if (w2l)
newVert = (*w2l) * newVert;
mesh.fVerts[i].Set(newVert.x, newVert.y, newVert.z);
}
mesh.fNumFaces = pMesh->numFaces;
mesh.fFaces = TRACKED_NEW UInt16[mesh.fNumFaces*3];
for (int i = 0; i < mesh.fNumFaces; i++)
{
Face* pFace = &pMesh->faces[i];
UInt16* pNFace = &mesh.fFaces[i * 3];
pNFace[0] = pFace->v[ parity ? 2 : 0 ]; // reverse winding if parity backwards
pNFace[1] = pFace->v[1];
pNFace[2] = pFace->v[ parity ? 0 : 2 ]; // ''
}
if (pDeleteMe)
delete pDeleteMe;
return true;
}
// BUILDBOXMESH
// Build the minimum bounding box (triangles and all) enclosing the given vertices
// DELETES the given vertex and face array
// ALLOCATES a new vertex and face array
// MODIFIES *all* the input parameters.
static void MakeBoxMesh(plMaxNode* node, plMaxMeshExtractor::NeutralMesh& mesh, hsPoint3& minV, hsPoint3& maxV)
{
hsPoint3* newVerts = TRACKED_NEW hsPoint3[8];
UInt16* newFaces = TRACKED_NEW UInt16[12 * 3];
newVerts[0].Set(minV.fX, minV.fY, minV.fZ);
newVerts[1].Set(maxV.fX, minV.fY, minV.fZ);
newVerts[2].Set(minV.fX, maxV.fY, minV.fZ);
newVerts[3].Set(maxV.fX, maxV.fY, minV.fZ);
newVerts[4].Set(minV.fX, minV.fY, maxV.fZ);
newVerts[5].Set(maxV.fX, minV.fY, maxV.fZ);
newVerts[6].Set(minV.fX, maxV.fY, maxV.fZ);
newVerts[7].Set(maxV.fX, maxV.fY, maxV.fZ);
UInt16 standardFaces[] = { 0, 2, 1,
1, 2, 3,
0, 1, 4,
1, 5, 4,
0, 4, 2,
2, 4, 6,
1, 3, 7,
7, 5, 1,
3, 2, 7,
2, 6, 7,
4, 7, 6,
4, 5, 7 };
memcpy(newFaces, standardFaces, sizeof(standardFaces));
delete [] mesh.fVerts;
mesh.fVerts = newVerts;
delete [] mesh.fFaces;
mesh.fFaces = newFaces;
mesh.fNumVerts = 8;
mesh.fNumFaces = 12;
}
static void MakeDummyMesh(plMaxNode* node, plMaxMeshExtractor::NeutralMesh& mesh)
{
hsPoint3 minV, maxV;
Object* thisObj = node->GetObjectRef();
DummyObject* thisDummy = (DummyObject*)thisObj;
Box3 thisBoundSurface = thisDummy->GetBox();
minV.fX = thisBoundSurface.Min().x;
minV.fY = thisBoundSurface.Min().y;
minV.fZ = thisBoundSurface.Min().z;
maxV.fX = thisBoundSurface.Max().x;
maxV.fY = thisBoundSurface.Max().y;
maxV.fZ = thisBoundSurface.Max().z;
MakeBoxMesh(node, mesh, minV, maxV);
}
// CREATEPLHKPHYSICALFROMMESHEASY
// Convenience function for getting from a max node to a plHKPhysical and the requisite
// Havok objects.
// The node and the scene object don't have to correspond to the same Max object.
// If the sAltNode is supplied, the node will be moved into the coordinate system of the
bool plMaxMeshExtractor::Extract(plMaxMeshExtractor::NeutralMesh& mesh, plMaxNode* node, bool makeAABB, plMaxNode* sOwningNode)
{
mesh.fNumVerts = mesh.fNumFaces = 0;
mesh.fVerts = nil;
mesh.fFaces = nil;
// if an alternate node was supplied, get its scene object. otherwise don't...
plMaxNode* masterNode = sOwningNode ? sOwningNode : node;
mesh.fL2W = masterNode->GetLocalToWorld44();
//
// Create the arrays of verts and faces
//
hsBool isDummy = (node->EvalWorldState(0).obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0));
if (isDummy)
{
hsMatrix44 w2l = masterNode->GetWorldToLocal44();
MakeDummyMesh(node, mesh);
// Localize the verts
//for (int i = 0; i < mesh.fNumVerts; i++)
// mesh.fVerts[i] = w2l * mesh.fVerts[i];
}
else
{
// only get the max world-to-local transform if the node is moveable or instanced. otherwise verts stay global.
Matrix3 w2l = masterNode->GetWorldToLocal();
// Matrix3 *localizer = nil;
// if (masterNode->IsMovable() || masterNode->GetForceLocal() || masterNode->GetInstanced())
// localizer = &w2l;
if (!MakeNormalMesh(node, mesh, &w2l))
return false;
if (makeAABB)
{
hsPoint3 minV(FLT_MAX, FLT_MAX, FLT_MAX), maxV(-FLT_MAX, -FLT_MAX, -FLT_MAX);
MeshMinMax(minV, maxV, mesh.fNumVerts, mesh.fVerts);
MakeBoxMesh(node, mesh, minV, maxV);
}
}
return true;
}