khanat-opennel-code/code/nel/src/3d/camera_col.cpp

590 lines
16 KiB
C++
Raw Normal View History

2010-05-06 00:08:41 +00:00
// 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 "std3d.h"
#include "nel/3d/camera_col.h"
#include "nel/misc/matrix.h"
#include "nel/misc/triangle.h"
using namespace std;
using namespace NLMISC;
namespace NL3D {
// ***************************************************************************
const float NL3D_CameraSmoothRadiusFactor= 4;
const float NL3D_CameraSmoothNumZSample= 20;
const float NL3D_CameraSmoothNumAngleSample= 10;
// ***************************************************************************
CCameraCol::CCameraCol()
{
}
// ***************************************************************************
void CCameraCol::build(const CVector &start, const CVector &end, float radius, bool cone)
{
// copy
_Start= start;
_End= end;
_Radius= radius;
_Cone= cone;
_SimpleRay= false;
// For camera smoothing
float maxRadiusFactor= NL3D_CameraSmoothRadiusFactor;
// not a Cone? => no smoothing
if(!_Cone)
maxRadiusFactor= 1;
// **** Compute Camera smooth infos
_MaxRadius= radius * maxRadiusFactor;
_MinRadiusProj= _Radius / (end-start).norm();
_MaxRadiusProj= _MaxRadius / (end-start).norm();
_RayNorm= (end-start).normed();
_RayLen= (end-start).norm();
_OODeltaRadiusProj= 0;
if(_MaxRadiusProj>_MinRadiusProj)
_OODeltaRadiusProj= 1.f / (_MaxRadiusProj-_MinRadiusProj);
// **** build the pyramid, with MaxRadius
// approximate with a box
CMatrix mat;
// Precision note: make the pyramid local to Start
mat.setRot(CVector::I, (start-end).normed(), CVector::K);
mat.normalize(CMatrix::YZX);
// build the start 4 points
CVector ps[4];
// cone or cylinder?
if(cone)
{
_NPlanes= 5;
// local to start!
ps[0]= CVector::Null;
ps[1]= CVector::Null;
ps[2]= CVector::Null;
ps[3]= CVector::Null;
}
else
{
_NPlanes= 6;
// local to start!
ps[0]= mat * CVector(_MaxRadius, 0, -_MaxRadius);
ps[1]= mat * CVector(_MaxRadius, 0, _MaxRadius);
ps[2]= mat * CVector(-_MaxRadius, 0, _MaxRadius);
ps[3]= mat * CVector(-_MaxRadius, 0, -_MaxRadius);
}
// build the end 4 points
CVector pe[4];
// local to start!
mat.setPos(end-start);
pe[0]= mat * CVector(_MaxRadius, 0, -_MaxRadius);
pe[1]= mat * CVector(_MaxRadius, 0, _MaxRadius);
pe[2]= mat * CVector(-_MaxRadius, 0, _MaxRadius);
pe[3]= mat * CVector(-_MaxRadius, 0, -_MaxRadius);
// try to roder for optimisation
// left/right
_Pyramid[0].make(ps[3], pe[3], pe[2]);
_Pyramid[1].make(ps[1], pe[1], pe[0]);
// back
_Pyramid[2].make(pe[0], pe[1], pe[2]);
// top-bottom
_Pyramid[3].make(ps[2], pe[2], pe[1]);
_Pyramid[4].make(ps[0], pe[0], pe[3]);
// front if not cone
if(!cone)
_Pyramid[5].make(ps[0], ps[2], ps[1]);
// **** build the bbox
_BBox.setCenter(start);
_BBox.extend(end);
// enlarge a bit for radius
_BBox.setHalfSize(_BBox.getHalfSize()+CVector(_MaxRadius, _MaxRadius, _MaxRadius));
}
// ***************************************************************************
void CCameraCol::buildRay(const CVector &start, const CVector &end)
{
// copy
_Start= start;
_End= end;
_Radius= 0.f;
_Cone= false;
_SimpleRay= true;
// compute infos
_MaxRadius= 0.f;
_MinRadiusProj= 0.f;
_MaxRadiusProj= 0.f;
_RayNorm= (end-start).normed();
_RayLen= (end-start).norm();
_OODeltaRadiusProj= 0;
// Don't need to build the pyramids here
// **** build the bbox
_BBox.setCenter(start);
_BBox.extend(end);
// enlarge a bit for radius
_BBox.setHalfSize(_BBox.getHalfSize()+CVector(0.01f, 0.01f, 0.01f));
}
// ***************************************************************************
void CCameraCol::setApplyMatrix(const CCameraCol &other, const NLMISC::CMatrix &matrix)
{
// get parameters modified by matrix
CVector start= matrix * other._Start;
CVector end= matrix * other._End;
float radius= other._Radius;
// scale the radius
if(matrix.hasScalePart())
{
// get the uniform scale
if(matrix.hasScaleUniform())
radius*= matrix.getScaleUniform();
// Tricky code, deduce a uniform scale. Should not arise
else
{
float meanScale= matrix.getI().norm() + matrix.getJ().norm() + matrix.getK().norm();
meanScale/= 3;
radius*= meanScale;
}
}
// rebuild
build(start, end, radius, other._Cone);
}
// ***************************************************************************
void CCameraCol::minimizeDistanceAgainstTri(const CVector &p0, const CVector &p1, const CVector &p2, float &sqrMinDist)
{
// If the camera collision is actually a ray test, use a simpler method
if(_SimpleRay)
{
intersectRay(p0, p1, p2, sqrMinDist);
return;
}
// Else compute the distance with a smoother way.
CVector *pIn= _ArrayIn;
CVector *pOut= _ArrayOut;
// **** clip triangle against the pyramid
// build the triangle, local to start for precision problems
pIn[0]= p0 - _Start;
pIn[1]= p1 - _Start;
pIn[2]= p2 - _Start;
sint nVert= 3;
// clip
for(uint i=0;i<_NPlanes;i++)
{
nVert= _Pyramid[i].clipPolygonBack(pIn, pOut, nVert);
swap(pIn, pOut);
if(!nVert)
break;
}
// **** if clipped => collision
if(nVert)
{
/*
Polygon nearest distance to a point is:
- the nearest distance of all vertices
- or the nearest distance to the plane (if the project lies in the polygon)
- or the nearest distance to each edge
NB: testing only points works with low radius, but may fails in general case
*/
// compute first the poly min distance
float sqrPolyMinDist= FLT_MAX;
// **** get the nearest distance for all points (avoid precision problem if doing only edge ones)
sint i;
for(i=0;i<nVert;i++)
{
// NB: pIn[i] is already local to start
float sqrDist= pIn[i].sqrnorm();
if(sqrDist<sqrPolyMinDist)
sqrPolyMinDist= sqrDist;
}
// **** get the nearest distance of the Start against each edge
for(i=0;i<nVert;i++)
{
const CVector &v0= pIn[i];
const CVector &v1= pIn[(i+1)%nVert];
CVector vDir= v1-v0;
// project on line
float fLen= vDir.sqrnorm(); // same as vDir * (v1 - v0)
// NB: Project CVector::Null, since we are local to start here!
float fStart= vDir * (-v0);
// if start projection in the edge
if(fStart>0 && fStart<fLen)
{
// compute distance to line
CVector proj= v0 + (fStart / fLen) * vDir;
// proj is local to Start
float sqrDist= proj.sqrnorm();
if(sqrDist<sqrPolyMinDist)
sqrPolyMinDist= sqrDist;
}
}
// **** get the nearest distance of the Start against the plane
// get the plane local to start
CPlane plane;
plane.make(p0-_Start, p1-_Start, p2-_Start);
// plane * StartLocalToStart == plane * CVector::Null == plane.d !
float planeDist= plane.d;
// need to do the poly inclusion test only if the plane dist is better than the vertices
float sqrPlaneDist= sqr(planeDist);
if(sqrPlaneDist < sqrPolyMinDist)
{
CVector normal= plane.getNormal();
// the projection of Start on the plane: StartLocalToStart +
CVector proj= planeDist * normal;
// test poly inclusion
sint sign= 0;
for(i=0;i<nVert;i++)
{
const CVector &v0= pIn[i];
const CVector &v1= pIn[(i+1)%nVert];
float d = ((v1-v0)^normal)*(proj-v0);
if(d<0)
{
if(sign==1) break;
else sign=-1;
}
else if(d>0)
{
if(sign==-1) break;
else sign=1;
}
else
break;
}
// if succeed, minimize
if(i==nVert)
sqrPolyMinDist= sqrPlaneDist;
}
// **** Camera Smoothing: modulate according to angle of poly against cone
// Camera smooth not enabled?
if(_MaxRadiusProj<=_MinRadiusProj)
{
// then just take minum
if(sqrPolyMinDist<sqrMinDist)
sqrMinDist= sqrPolyMinDist;
}
// Camera Smooth mode. if the unmodulated distance is lower than the current minDist,
// then this poly may be interesting, else don't have a chance
else if(sqrPolyMinDist<sqrMinDist)
{
float sampleZSize= _RayLen / NL3D_CameraSmoothNumZSample;
float sampleProjSize= 2*_MaxRadiusProj / NL3D_CameraSmoothNumAngleSample;
// **** Compute num Subdivision required
// To compute the number of subdivision, let's take the max of 2 req:
// the subdivision in Z (for Distance part of the function)
// the subdivision in Projection (for angle part of the function)
// Project all vertices to the plane
static CVector pProj[3+MaxNPlanes];
float minZ= _RayLen;
float maxZ= 0;
for(i=0;i<nVert;i++)
{
float z= pIn[i] * _RayNorm;
minZ= min(minZ, z);
maxZ= max(maxZ, z);
// cause of pyramid cliping, z should be >=0
if(z>0)
pProj[i]= pIn[i] / z;
else
pProj[i]= CVector::Null;
// make local
pProj[i]-= _RayNorm;
}
// Compute perimeter of projected poly
float perimeterProj= 0;
for(i=0;i<nVert;i++)
{
perimeterProj+= (pProj[(i+1)%nVert]-pProj[i]).norm();
}
// compute the number of subdivision required on Z
uint numSubdivZ= (uint)((maxZ-minZ) / sampleZSize);
// suppose a full projected quad perimeter will require max samples
uint numSubdivAngle= (uint)(perimeterProj / (4*sampleProjSize));
// the number of subdivision
uint numSubdiv= max(numSubdivZ, numSubdivAngle);
numSubdiv= max(numSubdiv, (uint)1);
float ooNumSubdiv= 1.f / (float)numSubdiv;
// **** Sample the polygon, to compute the minimum of the function
// for each tri of the polygon
for(sint tri=0;tri<nVert-2;tri++)
{
CVector lp[3];
// optim: prediv by numSubdiv
lp[0]= pIn[0] * ooNumSubdiv;
lp[1]= pIn[tri+1] * ooNumSubdiv;
lp[2]= pIn[tri+2] * ooNumSubdiv;
// sample using barycentric coordinates
for(uint i=0;i<=numSubdiv;i++)
{
for(uint j=0;j<=numSubdiv-i;j++)
{
uint k= numSubdiv - i - j;
CVector sample= lp[0] * (float)i + lp[1] * (float)j + lp[2] * (float)k;
// NB: sample is already local to start
float sqrDist= sample.sqrnorm();
// **** get the point projection
float z= sample * _RayNorm;
CVector proj;
// cause of pyramid cliping, z should be >=0
if(z>0)
proj= sample / z;
else
proj= CVector::Null;
// make local
proj-= _RayNorm;
// **** compute the Cone Linear factor (like a spot light)
float rayDist= proj.norm();
float angleFactor= (rayDist-_MinRadiusProj) * _OODeltaRadiusProj;
clamp(angleFactor, 0.f, 1.f);
// avoid C1 discontinuity when angleFactor==0
angleFactor= sqr(angleFactor);
// **** modulate, but to a bigger value! (ie raylen)
sqrDist= _RayLen * angleFactor + sqrtf(sqrDist) * (1-angleFactor);
sqrDist= sqr(sqrDist);
// if distance is lesser, take it
if(sqrDist<sqrMinDist)
sqrMinDist= sqrDist;
}
}
}
}
}
}
// ***************************************************************************
void CCameraCol::intersectRay(const CVector &p0, const CVector &p1, const CVector &p2, float &sqrMinDist)
{
// build the triangle and the plane from p0,p1,p2
CTriangle tri;
tri.V0= p0;
tri.V1= p1;
tri.V2= p2;
CPlane plane;
plane.make(p0,p1,p2);
// If doesn't intersect, quit
CVector hit;
if(!tri.intersect(_Start, _End, hit, plane))
return;
// Else compute the intersection distance factor
float f= (hit-_Start) * _RayNorm;
clamp(f, 0.f, _RayLen);
// set the result if less
f= sqr(f);
if(f<sqrMinDist)
sqrMinDist= f;
}
/*
// Perspective Project each vertices on the plane normalized to the ray, at Start + rayNormed * 1
// And then make local to the Point Start + rayNormed * 1 (ie _RayNorm since we are local to Start!).
for(i=0;i<nVert;i++)
{
float z= pIn[i] * _RayNorm;
// cause of pyramid cliping, z should be >=0
if(z>0)
pIn[i]= pIn[i] / z;
else
pIn[i]= CVector::Null;
// make local
pIn[i]-= _RayNorm;
}
// Compute now poly distance to the ray
// If the ray intersect the poly this is 0!!!
// else this is the min distance of each edge/vertex against CVector::Null
// test poly inclusion
sint sign= 0;
for(i=0;i<nVert;i++)
{
const CVector &v0= pIn[i];
const CVector &v1= pIn[(i+1)%nVert];
// _RayNorm should be the plane 's normal of the poly
float d = ((v1-v0)^_RayNorm)*(-v0);
if(d<0)
{
if(sign==1) break;
else sign=-1;
}
else if(d>0)
{
if(sign==-1) break;
else sign=1;
}
else
break;
}
// if succeed, then the poly fully intersect the ray => just minimize
if(i==nVert)
sqrMinDist= sqrPolyMinDist;
// else smooth distance!
else
{
// must get min distance of each projected edge/vertex againt origin
float sqrMinRayDist= FLT_MAX;
// get min distance of each vertex against origin
for(i=0;i<nVert;i++)
{
float sqrDist= pIn[i].sqrnorm();
if(sqrDist<sqrMinRayDist)
sqrMinRayDist= sqrDist;
}
// get distance of each edge against origin
for(i=0;i<nVert;i++)
{
const CVector &v0= pIn[i];
const CVector &v1= pIn[(i+1)%nVert];
CVector vDir= v1-v0;
// project on line
float fLen= vDir.sqrnorm(); // same as vDir * (v1 - v0)
// NB: Project CVector::Null
float fStart= vDir * (-v0);
// if origin projection in the edge
if(fStart>0 && fStart<fLen)
{
// compute distance to line
CVector proj= v0 + (fStart / fLen) * vDir;
// proj is local to Start
float sqrDist= proj.sqrnorm();
if(sqrDist<sqrMinRayDist)
sqrMinRayDist= sqrDist;
}
}
float minRayDist= sqrtf(sqrMinRayDist);
// OK! now we have the minRayDist
// compute the Cone Linear factor (like a spot light)
float angleFactor= (minRayDist-_MinRadiusProj) / (_MaxRadiusProj-_MinRadiusProj);
clamp(angleFactor, 0.f, 1.f);
// avoid C1 discontinuity when angleFactor==0
angleFactor= sqr(angleFactor);
// modulate, but to a bigger value! (ie raylen)
sqrPolyMinDist= _RayLen * angleFactor + sqrtf(sqrPolyMinDist) * (1-angleFactor);
sqrPolyMinDist= sqr(sqrPolyMinDist);
// then if the modified distance is still lower than minDist, set
if(sqrPolyMinDist<sqrMinDist)
sqrMinDist= sqrPolyMinDist;
}
*/
/*
const float sampleSize= 0.1f;
// Sample the triangle, to compute the minimum of the function
CVector lp[3];
float len[3];
lp[0]= p0-Start;
lp[1]= p1-Start;
lp[2]= p2-Start;
// compute max and min edge length
len[0]= (lp[1]-lp[0]).norm();
len[1]= (lp[2]-lp[1]).norm();
len[2]= (lp[0]-lp[2]).norm();
float meanLen= (len[0] + len[1] + len[2])/3;
// the number of subdivision
uint numSubdiv= meanLen / sampleSize;
numSubdiv= max(numSubdiv, (uint)1);
// preca
lp[0]/= numSubdiv;
lp[1]/= numSubdiv;
lp[2]/= numSubdiv;
// sample using barycentric coordinates
for(uint i=0;i<=numSubdiv;i++)
{
for(uint j=0;j<=numSubdiv-i;j++)
{
uint k= numSubdiv - i - j;
CVector sample= lp[0] * i + lp[1] * j + lp[2] * k;
// NB: sample is already local to start
float sqrDist= sample.sqrnorm();
// **** get the point projection
float z= sample * _RayNorm;
CVector proj;
// cause of pyramid cliping, z should be >=0
if(z>0)
proj= sample / z;
else
proj= CVector::Null;
// make local
proj-= _RayNorm;
// **** compute the Cone Linear factor (like a spot light)
float rayDist= proj.norm();
float angleFactor= (rayDist-_MinRadiusProj) / (_MaxRadiusProj-_MinRadiusProj);
clamp(angleFactor, 0.f, 1.f);
// avoid C1 discontinuity when angleFactor==0
angleFactor= sqr(angleFactor);
// **** modulate, but to a bigger value! (ie raylen)
sqrDist= _RayLen * angleFactor + sqrtf(sqrDist) * (1-angleFactor);
sqrDist= sqr(sqrDist);
// if distance is lesser, take it
if(sqrDist<sqrMinDist)
sqrMinDist= sqrDist;
}
}
*/
} // NL3D