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.
334 lines
7.9 KiB
334 lines
7.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/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
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 "memory.h" |
|
|
|
#include "hsTypes.h" |
|
#include "plGeoSpanDice.h" |
|
#include "plGeometrySpan.h" |
|
|
|
plGeoSpanDice::plGeoSpanDice() |
|
: fMinFaces(0), |
|
fMaxFaces(0) |
|
{ |
|
fMaxSize.Set(0,0,0); |
|
} |
|
|
|
plGeoSpanDice::~plGeoSpanDice() |
|
{ |
|
} |
|
|
|
hsBool plGeoSpanDice::Dice(hsTArray<plGeometrySpan*>& spans) const |
|
{ |
|
int startingCount = spans.GetCount(); |
|
|
|
hsTArray<plGeometrySpan*> out; |
|
hsTArray<plGeometrySpan*> next; |
|
|
|
while(spans.GetCount()) |
|
{ |
|
int i; |
|
for( i = 0; i < spans.GetCount(); i++ ) |
|
{ |
|
if( !IHalf(spans[i], next) ) |
|
{ |
|
out.Append(spans[i]); |
|
} |
|
} |
|
spans.Swap(next); |
|
next.SetCount(0); |
|
} |
|
spans.Swap(out); |
|
|
|
return spans.GetCount() != startingCount; |
|
} |
|
|
|
hsBool plGeoSpanDice::INeedSplitting(plGeometrySpan* src) const |
|
{ |
|
// Do we have enough faces to bother? |
|
if( fMinFaces ) |
|
{ |
|
if( src->fNumIndices < fMinFaces * 3 ) |
|
return false; |
|
} |
|
// Do we have enough faces to bother no matter how small we are? |
|
if( fMaxFaces ) |
|
{ |
|
if( src->fNumIndices > fMaxFaces * 3 ) |
|
return true; |
|
} |
|
// Are we big enough to bother? |
|
if( (fMaxSize.fX > 0) || (fMaxSize.fY > 0) || (fMaxSize.fZ > 0) ) |
|
{ |
|
hsPoint3 size = src->fLocalBounds.GetMaxs() - src->fLocalBounds.GetMins(); |
|
if( size.fX > fMaxSize.fX ) |
|
return true; |
|
if( size.fY > fMaxSize.fY ) |
|
return true; |
|
if( size.fZ > fMaxSize.fZ ) |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
hsBool plGeoSpanDice::IHalf(plGeometrySpan* src, hsTArray<plGeometrySpan*>& out, int exclAxis) const |
|
{ |
|
if( !INeedSplitting(src) ) |
|
return false; |
|
|
|
int iAxis = ISelectAxis(exclAxis, src); |
|
// Ran out of axes to try. |
|
if( iAxis < 0 ) |
|
return false; |
|
|
|
hsScalar midPoint = src->fLocalBounds.GetCenter()[iAxis]; |
|
|
|
hsTArray<UInt32> loTris; |
|
hsTArray<UInt32> hiTris; |
|
|
|
UInt16* indexData = src->fIndexData; |
|
|
|
int numTris = src->fNumIndices / 3; |
|
|
|
int stride = src->GetVertexSize(src->fFormat); |
|
|
|
int i; |
|
for( i = 0; i < numTris; i++ ) |
|
{ |
|
hsPoint3& pos0 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride); |
|
hsPoint3& pos1 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride); |
|
hsPoint3& pos2 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride); |
|
|
|
if( (pos0[iAxis] >= midPoint) |
|
&&(pos1[iAxis] >= midPoint) |
|
&&(pos2[iAxis] >= midPoint) ) |
|
{ |
|
hiTris.Append(i); |
|
} |
|
else |
|
{ |
|
loTris.Append(i); |
|
} |
|
} |
|
|
|
// This axis isn't working out, try another. |
|
if( !hiTris.GetCount() || !loTris.GetCount() ) |
|
return IHalf(src, out, exclAxis | (1 << iAxis)); |
|
|
|
|
|
plGeometrySpan* loDst = IExtractTris(src, loTris); |
|
plGeometrySpan* hiDst = IExtractTris(src, hiTris); |
|
|
|
delete src; |
|
|
|
out.Append(loDst); |
|
out.Append(hiDst); |
|
|
|
return true; |
|
} |
|
|
|
int plGeoSpanDice::ISelectAxis(int exclAxis, plGeometrySpan* src) const |
|
{ |
|
int iAxis = -1; |
|
hsScalar maxDim = 0; |
|
|
|
int i; |
|
for( i = 0; i < 3; i++ ) |
|
{ |
|
// Check to see if we've already tried this one. |
|
if( exclAxis & (1 << i) ) |
|
continue; |
|
|
|
hsScalar dim = src->fLocalBounds.GetMaxs()[i] - src->fLocalBounds.GetMins()[i]; |
|
if( dim > maxDim ) |
|
{ |
|
maxDim = dim; |
|
iAxis = i; |
|
} |
|
} |
|
return iAxis; |
|
} |
|
|
|
plGeometrySpan* plGeoSpanDice::IExtractTris(plGeometrySpan* src, hsTArray<UInt32>& tris) const |
|
{ |
|
// First off, find out how many and which vers we're talking here. |
|
// Easiest way is while we're building the LUTs we'll want later anyway. |
|
hsTArray<Int16> fwdLUT; |
|
fwdLUT.SetCount(src->fNumVerts); |
|
memset(fwdLUT.AcquireArray(), -1, src->fNumVerts * sizeof(*fwdLUT.AcquireArray())); |
|
|
|
hsTArray<UInt16> bckLUT; |
|
bckLUT.SetCount(0); |
|
|
|
int i; |
|
for( i = 0; i < tris.GetCount(); i++ ) |
|
{ |
|
UInt16* idx = src->fIndexData + tris[i] * 3; |
|
|
|
if( fwdLUT[*idx] < 0 ) |
|
{ |
|
fwdLUT[*idx] = bckLUT.GetCount(); |
|
bckLUT.Append(*idx); |
|
} |
|
|
|
idx++; |
|
|
|
if( fwdLUT[*idx] < 0 ) |
|
{ |
|
fwdLUT[*idx] = bckLUT.GetCount(); |
|
bckLUT.Append(*idx); |
|
} |
|
|
|
idx++; |
|
|
|
if( fwdLUT[*idx] < 0 ) |
|
{ |
|
fwdLUT[*idx] = bckLUT.GetCount(); |
|
bckLUT.Append(*idx); |
|
} |
|
} |
|
|
|
int numVerts = bckLUT.GetCount(); |
|
int numTris = tris.GetCount(); |
|
|
|
plGeometrySpan* dst = IAllocSpace(src, numVerts, numTris); |
|
|
|
// Okay, set the index data. |
|
UInt16* idxTrav = dst->fIndexData; |
|
for( i = 0; i < tris.GetCount(); i++ ) |
|
{ |
|
*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 0] ]; |
|
*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 1] ]; |
|
*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 2] ]; |
|
} |
|
|
|
// Copy over the basic vertex data |
|
// We'll update the bounds as we go. |
|
int stride = src->GetVertexSize(src->fFormat); |
|
|
|
hsBounds3Ext localBnd; |
|
localBnd.MakeEmpty(); |
|
UInt8* vtxTrav = dst->fVertexData; |
|
for( i = 0; i < numVerts; i++ ) |
|
{ |
|
memcpy(vtxTrav, src->fVertexData + bckLUT[i] * stride, stride); |
|
|
|
hsPoint3* pos = (hsPoint3*)vtxTrav; |
|
localBnd.Union(pos); |
|
vtxTrav += stride; |
|
} |
|
if( src->fProps & plGeometrySpan::kWaterHeight ) |
|
{ |
|
src->AdjustBounds(localBnd); |
|
} |
|
dst->fLocalBounds = localBnd; |
|
|
|
// Now the rest of this optional garbage. |
|
if( src->fMultColor ) |
|
{ |
|
for( i = 0; i < numVerts; i++ ) |
|
{ |
|
dst->fMultColor[i] = src->fMultColor[bckLUT[i]]; |
|
} |
|
} |
|
if( src->fAddColor ) |
|
{ |
|
for( i = 0; i < numVerts; i++ ) |
|
{ |
|
dst->fAddColor[i] = src->fAddColor[bckLUT[i]]; |
|
} |
|
} |
|
if( src->fDiffuseRGBA ) |
|
{ |
|
for( i = 0; i < numVerts; i++ ) |
|
{ |
|
dst->fDiffuseRGBA[i] = src->fDiffuseRGBA[bckLUT[i]]; |
|
} |
|
} |
|
if( src->fSpecularRGBA ) |
|
{ |
|
for( i = 0; i < numVerts; i++ ) |
|
{ |
|
dst->fSpecularRGBA[i] = src->fSpecularRGBA[bckLUT[i]]; |
|
} |
|
} |
|
dst->fMaxOwner = src->fMaxOwner; |
|
|
|
return dst; |
|
} |
|
|
|
plGeometrySpan* plGeoSpanDice::IAllocSpace(plGeometrySpan* src, int numVerts, int numTris) const |
|
{ |
|
plGeometrySpan* dst = TRACKED_NEW plGeometrySpan; |
|
// Do a structure copy here. That's okay, because we're going to immediately |
|
// fix up the pointers and counters that shouldn't have been copied. If |
|
// plGeometrySpan ever gets a copy constructor, this'll blow wide open. |
|
*dst = *src; |
|
|
|
int stride = src->GetVertexSize(src->fFormat); |
|
|
|
dst->fNumIndices = numTris * 3; |
|
dst->fIndexData = TRACKED_NEW UInt16[dst->fNumIndices]; |
|
|
|
dst->fNumVerts = numVerts; |
|
dst->fVertexData = TRACKED_NEW UInt8[numVerts * stride]; |
|
|
|
if( src->fMultColor ) |
|
{ |
|
dst->fMultColor = TRACKED_NEW hsColorRGBA[numVerts]; |
|
} |
|
if( src->fAddColor ) |
|
{ |
|
dst->fAddColor = TRACKED_NEW hsColorRGBA[numVerts]; |
|
} |
|
if( src->fDiffuseRGBA ) |
|
{ |
|
dst->fDiffuseRGBA = TRACKED_NEW UInt32[numVerts]; |
|
} |
|
if( src->fSpecularRGBA ) |
|
{ |
|
dst->fSpecularRGBA = TRACKED_NEW UInt32[numVerts]; |
|
} |
|
|
|
return dst; |
|
} |