mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-24 16:16:14 +00:00
344 lines
10 KiB
C++
344 lines
10 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "stdmisc.h"
|
|
|
|
#include "nel/misc/aabbox.h"
|
|
#include "nel/misc/polygon.h"
|
|
#include "nel/misc/bsphere.h"
|
|
#include "nel/misc/matrix.h"
|
|
|
|
|
|
|
|
namespace NLMISC {
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::clipFront(const CPlane &p) const
|
|
{
|
|
CVector hswap;
|
|
|
|
// The bbox is front of the plane if only one of his vertex is in front.
|
|
if(p*(Center + HalfSize) > 0) return true;
|
|
if(p*(Center - HalfSize) > 0) return true;
|
|
hswap.set(-HalfSize.x, HalfSize.y, HalfSize.z);
|
|
if(p*(Center + hswap) > 0) return true;
|
|
if(p*(Center - hswap) > 0) return true;
|
|
hswap.set(HalfSize.x, -HalfSize.y, HalfSize.z);
|
|
if(p*(Center + hswap) > 0) return true;
|
|
if(p*(Center - hswap) > 0) return true;
|
|
hswap.set(HalfSize.x, HalfSize.y, -HalfSize.z);
|
|
if(p*(Center + hswap) > 0) return true;
|
|
if(p*(Center - hswap) > 0) return true;
|
|
|
|
return false;
|
|
}
|
|
// ***************************************************************************
|
|
bool CAABBox::clipBack(const CPlane &p) const
|
|
{
|
|
CVector hswap;
|
|
|
|
// The bbox is back of the plane if only one of his vertex is in back.
|
|
if(p*(Center + HalfSize) < 0) return true;
|
|
if(p*(Center - HalfSize) < 0) return true;
|
|
hswap.set(-HalfSize.x, HalfSize.y, HalfSize.z);
|
|
if(p*(Center + hswap) < 0) return true;
|
|
if(p*(Center - hswap) < 0) return true;
|
|
hswap.set(HalfSize.x, -HalfSize.y, HalfSize.z);
|
|
if(p*(Center + hswap) < 0) return true;
|
|
if(p*(Center - hswap) < 0) return true;
|
|
hswap.set(HalfSize.x, HalfSize.y, -HalfSize.z);
|
|
if(p*(Center + hswap) < 0) return true;
|
|
if(p*(Center - hswap) < 0) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::include(const CVector &a) const
|
|
{
|
|
if(Center.x+HalfSize.x<a.x) return false;
|
|
if(Center.x-HalfSize.x>a.x) return false;
|
|
if(Center.y+HalfSize.y<a.y) return false;
|
|
if(Center.y-HalfSize.y>a.y) return false;
|
|
if(Center.z+HalfSize.z<a.z) return false;
|
|
if(Center.z-HalfSize.z>a.z) return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::include(const CAABBox &box) const
|
|
{
|
|
if(Center.x+HalfSize.x < box.Center.x+box.HalfSize.x) return false;
|
|
if(Center.x-HalfSize.x > box.Center.x-box.HalfSize.x) return false;
|
|
if(Center.y+HalfSize.y < box.Center.y+box.HalfSize.y) return false;
|
|
if(Center.y-HalfSize.y > box.Center.y-box.HalfSize.y) return false;
|
|
if(Center.z+HalfSize.z < box.Center.z+box.HalfSize.z) return false;
|
|
if(Center.z-HalfSize.z > box.Center.z-box.HalfSize.z) return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::intersect(const CAABBox &box) const
|
|
{
|
|
CVector mina = getMin(), maxa = getMax(),
|
|
minb = box.getMin(), maxb = box.getMax();
|
|
|
|
return ! ( mina.x > maxb.x ||
|
|
mina.y > maxb.y ||
|
|
mina.z > maxb.z ||
|
|
minb.x > maxa.x ||
|
|
minb.y > maxa.y ||
|
|
minb.z > maxa.z);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::intersect(const CVector &a, const CVector &b, const CVector &c) const
|
|
{
|
|
// Trivial test.
|
|
if(include(a) || include(b) || include(c))
|
|
return true;
|
|
// Else, must test if the polygon intersect the pyamid.
|
|
CPlane planes[6];
|
|
makePyramid(planes);
|
|
CPolygon poly(a,b,c);
|
|
poly.clip(planes, 6);
|
|
if(poly.getNumVertices()==0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::intersect(const CVector &a, const CVector &b) const
|
|
{
|
|
// Trivial test.
|
|
if(include(a) || include(b))
|
|
return true;
|
|
// Else, must test if the segment intersect the pyamid.
|
|
CPlane planes[6];
|
|
makePyramid(planes);
|
|
CVector p0=a , p1=b;
|
|
// clip the segment against all planes
|
|
for(uint i=0;i<6;i++)
|
|
{
|
|
if(!planes[i].clipSegmentBack(p0, p1))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::clipSegment(CVector &a, CVector &b) const
|
|
{
|
|
// Trivial test. If both are in, they are inchanged
|
|
if(include(a) && include(b))
|
|
return true;
|
|
// Else, must clip the segment againts the pyamid.
|
|
CPlane planes[6];
|
|
makePyramid(planes);
|
|
CVector p0=a , p1=b;
|
|
// clip the segment against all planes
|
|
for(uint i=0;i<6;i++)
|
|
{
|
|
if(!planes[i].clipSegmentBack(p0, p1))
|
|
return false;
|
|
}
|
|
// get result
|
|
a= p0;
|
|
b= p1;
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CAABBox::intersect(const CBSphere &s) const
|
|
{
|
|
if (Center.x + HalfSize.x < s.Center.x - s.Radius) return false;
|
|
if (Center.y + HalfSize.y < s.Center.y - s.Radius) return false;
|
|
if (Center.z + HalfSize.z < s.Center.z - s.Radius) return false;
|
|
|
|
if (Center.x - HalfSize.x > s.Center.x + s.Radius) return false;
|
|
if (Center.y - HalfSize.y > s.Center.y + s.Radius) return false;
|
|
if (Center.z - HalfSize.z > s.Center.z + s.Radius) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAABBox::makePyramid(CPlane planes[6]) const
|
|
{
|
|
planes[0].make(CVector(-1,0,0), Center-HalfSize);
|
|
planes[1].make(CVector(+1,0,0), Center+HalfSize);
|
|
planes[2].make(CVector(0,-1,0), Center-HalfSize);
|
|
planes[3].make(CVector(0,+1,0), Center+HalfSize);
|
|
planes[4].make(CVector(0,0,-1), Center-HalfSize);
|
|
planes[5].make(CVector(0,0,+1), Center+HalfSize);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAABBox::serial(NLMISC::IStream &f)
|
|
{
|
|
/* ***********************************************
|
|
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
|
|
* It can be loaded/called through CAsyncFileManager for instance
|
|
* ***********************************************/
|
|
(void)f.serialVersion(0);
|
|
f.serial(Center);
|
|
f.serial(HalfSize);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAABBox::extend(const CVector &v)
|
|
{
|
|
CVector bmin= getMin(), bmax= getMax();
|
|
|
|
bmin.minof(bmin, v);
|
|
bmax.maxof(bmax, v);
|
|
setMinMax(bmin, bmax);
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
/**
|
|
* Compute the union of 2 aabboxes, that is the aabbox that contains the 2.
|
|
* Should end up in NLMISC
|
|
*/
|
|
|
|
CAABBox CAABBox::computeAABBoxUnion(const CAABBox &b1, const CAABBox &b2)
|
|
{
|
|
CAABBox result;
|
|
CVector min, max;
|
|
CVector min1 = b1.getMin()
|
|
,max1 = b1.getMax()
|
|
,min2 = b2.getMin()
|
|
,max2 = b2.getMax();
|
|
max.maxof(max1, max2);
|
|
min.minof(min1, min2);
|
|
result.setMinMax(min, max);
|
|
return result;
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
void CAABBox::computeIntersection(const CAABBox &b1, const CAABBox &b2)
|
|
{
|
|
CVector min1 = b1.getMin(), max1 = b1.getMax(),
|
|
min2 = b2.getMin(), max2 = b2.getMax();
|
|
CVector minr, maxr;
|
|
|
|
// don't test if intersect or not.
|
|
maxr.minof(max1, max2);
|
|
minr.maxof(min1, min2);
|
|
|
|
setMinMax(minr, maxr);
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
CAABBox CAABBox::transformAABBox(const CMatrix &mat, const CAABBox &box)
|
|
{
|
|
// TODO : optimize this a bit if possible...
|
|
CAABBox result;
|
|
|
|
/* OMG. Old code was false!!
|
|
if we have ht= M * h
|
|
then CVector(-ht.x, ht.y, ht.z) != M * CVector(-h.x, h.y, h.z) !!!!
|
|
*/
|
|
// compute corners.
|
|
CVector p[8];
|
|
CVector min= box.getMin();
|
|
CVector max= box.getMax();
|
|
p[0].set(min.x, min.y, min.z);
|
|
p[1].set(max.x, min.y, min.z);
|
|
p[2].set(min.x, max.y, min.z);
|
|
p[3].set(max.x, max.y, min.z);
|
|
p[4].set(min.x, min.y, max.z);
|
|
p[5].set(max.x, min.y, max.z);
|
|
p[6].set(min.x, max.y, max.z);
|
|
p[7].set(max.x, max.y, max.z);
|
|
CVector tmp;
|
|
min = max = mat * p[0];
|
|
// transform corners.
|
|
for(uint i=1;i<8;i++)
|
|
{
|
|
tmp= mat * p[i];
|
|
min.minof(min, tmp);
|
|
max.maxof(max, tmp);
|
|
}
|
|
|
|
result.setMinMax(min, max);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBoxExt::clipFront(const CPlane &p) const
|
|
{
|
|
// Assume normalized planes.
|
|
|
|
// if( SpherMax OUT ) return false.
|
|
float d= p*Center;
|
|
if(d<-RadiusMax)
|
|
return false;
|
|
// if( SphereMin IN ) return true;
|
|
if(d>-RadiusMin)
|
|
return true;
|
|
|
|
// else, standard clip box.
|
|
return CAABBox::clipFront(p);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAABBoxExt::clipBack(const CPlane &p) const
|
|
{
|
|
// Assume normalized planes.
|
|
|
|
// if( SpherMax OUT ) return false.
|
|
float d= p*Center;
|
|
if(d>RadiusMax)
|
|
return false;
|
|
// if( SphereMin IN ) return true;
|
|
if(d<RadiusMin)
|
|
return true;
|
|
|
|
// else, standard clip box.
|
|
return CAABBox::clipBack(p);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAABBoxExt::serial(NLMISC::IStream &f)
|
|
{
|
|
/* ***********************************************
|
|
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
|
|
* It can be loaded/called through CAsyncFileManager for instance
|
|
* ***********************************************/
|
|
CAABBox::serial(f);
|
|
if(f.isReading())
|
|
updateRadius();
|
|
}
|
|
|
|
|
|
} // NLMISC
|