557 lines
17 KiB
C++
557 lines
17 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 "std3d.h"
|
|
|
|
#include "nel/3d/visual_collision_mesh.h"
|
|
#include "nel/3d/quad_grid.h"
|
|
#include "nel/3d/camera_col.h"
|
|
#include "nel/3d/driver.h"
|
|
#include "nel/3d/shadow_map.h"
|
|
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
|
|
// TestYoyo. external debug flag
|
|
bool TESTYOYO_VCM_RedShadow= false;
|
|
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
// ***************************************************************************
|
|
#define NL3D_VCM_SHADOW_NUM_CLIP_PLANE 7
|
|
#define NL3D_VCM_SHADOW_NUM_CLIP_PLANE_SHIFT (1<<NL3D_VCM_SHADOW_NUM_CLIP_PLANE)
|
|
#define NL3D_VCM_SHADOW_NUM_CLIP_PLANE_MASK (NL3D_VCM_SHADOW_NUM_CLIP_PLANE_SHIFT-1)
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CStaticGrid
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionMesh::CStaticGrid::create(uint nbQuads, uint nbElts, const NLMISC::CAABBox &gridBBox)
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
nlassert(nbQuads>0 && isPowerOf2(nbQuads));
|
|
|
|
// init the grid
|
|
_GridSize= nbQuads;
|
|
_GridSizePower= getPowerOf2(nbQuads);
|
|
_Grid.resize(_GridSize*_GridSize);
|
|
// start with 0 elt in each case
|
|
memset(_Grid.getPtr(), 0, _Grid.size() * sizeof(CCase));
|
|
|
|
// init the Elt Build
|
|
_EltBuild.resize(nbElts);
|
|
|
|
// total size is 0
|
|
_GridDataSize= 0;
|
|
|
|
// bbox init
|
|
_GridPos= gridBBox.getMin();
|
|
_GridScale= gridBBox.getSize();
|
|
_GridScale.x= _GridSize / _GridScale.x;
|
|
_GridScale.y= _GridSize / _GridScale.y;
|
|
|
|
// reset intersection data
|
|
_ItSession= 0;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionMesh::CStaticGrid::add(uint16 id, const NLMISC::CAABBox &bbox)
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
CVector minp= bbox.getMin() - _GridPos;
|
|
CVector maxp= bbox.getMax() - _GridPos;
|
|
|
|
// compute the 2D bbox
|
|
sint xmin= (sint)floorf(minp.x*_GridScale.x);
|
|
sint ymin= (sint)floorf(minp.y*_GridScale.y);
|
|
sint xmax= (sint)ceilf(maxp.x*_GridScale.x);
|
|
sint ymax= (sint)ceilf(maxp.y*_GridScale.y);
|
|
clamp(xmin, 0, (sint)_GridSize-1);
|
|
clamp(ymin, 0, (sint)_GridSize-1);
|
|
clamp(xmax, xmin+1, (sint)_GridSize);
|
|
clamp(ymax, ymin+1, (sint)_GridSize);
|
|
|
|
// set in the elt build
|
|
_EltBuild[id].X0= xmin;
|
|
_EltBuild[id].Y0= ymin;
|
|
_EltBuild[id].X1= xmax;
|
|
_EltBuild[id].Y1= ymax;
|
|
|
|
// for each case touched, increment NumElts
|
|
for(uint y=ymin;y<(uint)ymax;y++)
|
|
{
|
|
for(uint x=xmin;x<(uint)xmax;x++)
|
|
{
|
|
_Grid[(y<<_GridSizePower)+x].NumElts++;
|
|
_GridDataSize++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionMesh::CStaticGrid::compile()
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
uint i;
|
|
|
|
// create the data
|
|
_GridData.resize(_GridDataSize);
|
|
|
|
// Init Start ptr for each case
|
|
uint idx= 0;
|
|
for(i=0;i<_Grid.size();i++)
|
|
{
|
|
_Grid[i].Start= idx;
|
|
idx+= _Grid[i].NumElts;
|
|
// reset NumElts, because use it like an index below
|
|
_Grid[i].NumElts= 0;
|
|
}
|
|
nlassert(_GridDataSize==idx);
|
|
|
|
// For each element, fill the grid and grid data
|
|
for(i=0;i<_EltBuild.size();i++)
|
|
{
|
|
CEltBuild &eb= _EltBuild[i];
|
|
|
|
for(uint y=eb.Y0;y<eb.Y1;y++)
|
|
{
|
|
for(uint x=eb.X0;x<eb.X1;x++)
|
|
{
|
|
CCase &gcase= _Grid[(y<<_GridSizePower)+x];
|
|
uint idx= gcase.Start + gcase.NumElts;
|
|
// store the idx
|
|
_GridData[idx]= i;
|
|
// increment the number of elements for this case
|
|
gcase.NumElts++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// create the temp array used for intersection test
|
|
_Sessions.resize(_EltBuild.size());
|
|
_Sessions.fill(0);
|
|
|
|
// clear no more needed data
|
|
_EltBuild.clear();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
uint CVisualCollisionMesh::CStaticGrid::select(const NLMISC::CAABBox &bbox, std::vector<uint16> &res)
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
// increment the intersection session
|
|
_ItSession++;
|
|
// enlarge the result array as needed
|
|
if(res.size()<_Sessions.size())
|
|
res.resize(_Sessions.size());
|
|
// the number of selected element
|
|
uint numSel= 0;
|
|
|
|
// compute the 2D bbox
|
|
CVector minp= bbox.getMin() - _GridPos;
|
|
CVector maxp= bbox.getMax() - _GridPos;
|
|
sint xmin= (sint)floorf(minp.x*_GridScale.x);
|
|
sint ymin= (sint)floorf(minp.y*_GridScale.y);
|
|
sint xmax= (sint)ceilf(maxp.x*_GridScale.x);
|
|
sint ymax= (sint)ceilf(maxp.y*_GridScale.y);
|
|
clamp(xmin, 0, (sint)_GridSize-1);
|
|
clamp(ymin, 0, (sint)_GridSize-1);
|
|
clamp(xmax, xmin+1, (sint)_GridSize);
|
|
clamp(ymax, ymin+1, (sint)_GridSize);
|
|
|
|
// for each case touched, increment NumElts
|
|
for(uint y=ymin;y<(uint)ymax;y++)
|
|
{
|
|
for(uint x=xmin;x<(uint)xmax;x++)
|
|
{
|
|
CCase &gcase= _Grid[(y<<_GridSizePower)+x];
|
|
// for each element in this case
|
|
for(uint i= gcase.Start;i<gcase.Start + gcase.NumElts;i++)
|
|
{
|
|
uint elt= _GridData[i];
|
|
|
|
// if not alread inserted in the dest
|
|
if(_Sessions[elt]!=_ItSession)
|
|
{
|
|
// mark as intersected
|
|
_Sessions[elt]= _ItSession;
|
|
// append
|
|
res[numSel++]= elt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// return the number of selected elements
|
|
return numSel;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CVisualCollisionMesh
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
CVisualCollisionMesh::CVisualCollisionMesh()
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CVisualCollisionMesh::build(const std::vector<CVector> &vertices, const std::vector<uint32> &triangles, CVertexBuffer &vbForShadowRender)
|
|
{
|
|
/* ***********************************************
|
|
* 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
|
|
* ***********************************************/
|
|
|
|
uint i;
|
|
// if no vertices, or no triangles, abort
|
|
if(vertices.empty())
|
|
return false;
|
|
if(triangles.empty())
|
|
return false;
|
|
// vertices and triangles id are stored in uint16 form. so their should not be more than 65535*3 indices
|
|
if(vertices.size()>65535 || triangles.size()>65535*3)
|
|
return false;
|
|
|
|
// copy
|
|
_Vertices= vertices;
|
|
|
|
// compress indexes to 16 bits
|
|
_Triangles.resize(triangles.size());
|
|
for(i=0;i<_Triangles.size();i++)
|
|
_Triangles[i]= (uint16)triangles[i];
|
|
|
|
// Build the Local bbox for this col mesh
|
|
CAABBox localBBox;
|
|
localBBox.setCenter(vertices[0]);
|
|
for(i=1;i<vertices.size();i++)
|
|
localBBox.extend(vertices[i]);
|
|
|
|
// Build the Static Grid
|
|
uint numTris= (uint)triangles.size()/3;
|
|
_QuadGrid.create(16, numTris, localBBox);
|
|
// Add all triangles
|
|
for(i=0;i<numTris;i++)
|
|
{
|
|
CAABBox bb;
|
|
bb.setCenter(_Vertices[_Triangles[i*3+0]]);
|
|
bb.extend(_Vertices[_Triangles[i*3+1]]);
|
|
bb.extend(_Vertices[_Triangles[i*3+2]]);
|
|
_QuadGrid.add(i, bb);
|
|
}
|
|
// compile
|
|
_QuadGrid.compile();
|
|
|
|
|
|
// Keep a RefPtr on the AGP vertex Buffer for shadow receiving
|
|
_VertexBuffer= &vbForShadowRender;
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
float CVisualCollisionMesh::getCameraCollision(const CMatrix &instanceMatrix, CCameraCol &camCol)
|
|
{
|
|
// Make the Camera Collision local to the mesh!
|
|
CCameraCol camColLocal;
|
|
camColLocal.setApplyMatrix(camCol, instanceMatrix.inverted());
|
|
|
|
|
|
// Select triangles
|
|
static std::vector<uint16> selection;
|
|
uint numSel= _QuadGrid.select(camColLocal.getBBox(), selection);
|
|
|
|
// **** For all triangles, test if intersect the camera collision
|
|
float sqrMinDist= FLT_MAX;
|
|
for(uint i=0;i<numSel;i++)
|
|
{
|
|
uint triId= selection[i];
|
|
// build the triangle
|
|
camColLocal.minimizeDistanceAgainstTri(
|
|
_Vertices[_Triangles[triId*3+0]],
|
|
_Vertices[_Triangles[triId*3+1]],
|
|
_Vertices[_Triangles[triId*3+2]],
|
|
sqrMinDist);
|
|
}
|
|
|
|
// **** return the collision found, between [0,1]
|
|
if(sqrMinDist == FLT_MAX)
|
|
return 1;
|
|
else
|
|
{
|
|
float f= 1;
|
|
float d= camColLocal.getRayLen();
|
|
if(d>0)
|
|
{
|
|
f= sqrtf(sqrMinDist) / d;
|
|
f= min(f, 1.f);
|
|
}
|
|
return f;
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
NLMISC::CAABBox CVisualCollisionMesh::computeWorldBBox(const CMatrix &instanceMatrix)
|
|
{
|
|
CAABBox ret;
|
|
if(!_Vertices.empty())
|
|
{
|
|
ret.setCenter(instanceMatrix*_Vertices[0]);
|
|
for(uint i=1;i<_Vertices.size();i++)
|
|
{
|
|
ret.extend(instanceMatrix*_Vertices[i]);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionMesh::receiveShadowMap(const NLMISC::CMatrix &instanceMatrix, const CShadowContext &shadowContext)
|
|
{
|
|
// empty mesh => no op
|
|
if(_Vertices.empty())
|
|
return;
|
|
|
|
// The VertexBuffer RefPtr has been released? quit
|
|
if(_VertexBuffer == NULL)
|
|
return;
|
|
|
|
|
|
// **** Select triangles to be rendered with quadGrid
|
|
// select with quadGrid local in mesh
|
|
CAABBox localBB;
|
|
localBB= CAABBox::transformAABBox(instanceMatrix.inverted(), shadowContext.ShadowWorldBB);
|
|
static std::vector<uint16> triInQuadGrid;
|
|
uint numTrisInQuadGrid= _QuadGrid.select(localBB, triInQuadGrid);
|
|
|
|
// no intersection at all? quit
|
|
if(numTrisInQuadGrid==0)
|
|
return;
|
|
|
|
|
|
// **** prepare more precise Clip with shadow pyramid
|
|
// enlarge temp flag array
|
|
static std::vector<uint8> vertexFlags;
|
|
if(vertexFlags.size()<_Vertices.size())
|
|
vertexFlags.resize(_Vertices.size());
|
|
// reset all to 0
|
|
memset(&vertexFlags[0], 0, _Vertices.size()*sizeof(uint8));
|
|
|
|
// Compute the "LocalToInstance" shadow Clip Volume
|
|
static std::vector<CPlane> localClipPlanes;
|
|
/* We want to apply to plane this matrix: IM-1 * MCasterPos,
|
|
where IM=instanceMatrix and MCasterPos= matrix translation of "shadowContext.CasterPos"
|
|
BUT, since to transform a plane, we must do plane * M-1, then compute this matrix:
|
|
localMat= MCasterPos-1 * IM
|
|
*/
|
|
CMatrix localMat;
|
|
localMat.setPos(-shadowContext.CasterPos);
|
|
localMat*= instanceMatrix;
|
|
// Allow max bits of planes clip.
|
|
localClipPlanes.resize(min((uint)shadowContext.ShadowMap->LocalClipPlanes.size(), (uint)NL3D_VCM_SHADOW_NUM_CLIP_PLANE));
|
|
// Transform into Mesh local space
|
|
for(uint i=0;i<localClipPlanes.size();i++)
|
|
{
|
|
localClipPlanes[i]= shadowContext.ShadowMap->LocalClipPlanes[i] * localMat;
|
|
}
|
|
|
|
|
|
// **** Clip and fill the triangles
|
|
uint currentTriIdx= 0;
|
|
// enlarge the index buffer as max of triangles possibly intersected
|
|
shadowContext.IndexBuffer.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
|
|
if(shadowContext.IndexBuffer.getNumIndexes()<numTrisInQuadGrid*3)
|
|
shadowContext.IndexBuffer.setNumIndexes(numTrisInQuadGrid*3);
|
|
|
|
// Start to clip and fill
|
|
{
|
|
CIndexBufferReadWrite iba;
|
|
shadowContext.IndexBuffer.lock(iba);
|
|
if (iba.getFormat() == CIndexBuffer::Indices32)
|
|
{
|
|
uint32 *ibPtr= (uint32 *) iba.getPtr();
|
|
// for all triangles selected with the quadgrid
|
|
for(uint triq=0; triq<numTrisInQuadGrid;triq++)
|
|
{
|
|
uint triId[3];
|
|
triId[0]= _Triangles[uint(triInQuadGrid[triq])*3+0];
|
|
triId[1]= _Triangles[uint(triInQuadGrid[triq])*3+1];
|
|
triId[2]= _Triangles[uint(triInQuadGrid[triq])*3+2];
|
|
uint triFlag= NL3D_VCM_SHADOW_NUM_CLIP_PLANE_MASK;
|
|
|
|
// for all vertices, clip them
|
|
for(uint i=0;i<3;i++)
|
|
{
|
|
uint vid= triId[i];
|
|
uint vf= vertexFlags[vid];
|
|
|
|
// if this vertex is still not computed
|
|
if(!vf)
|
|
{
|
|
// For all planes of the Clip Volume, clip this vertex.
|
|
for(uint j=0;j<localClipPlanes.size();j++)
|
|
{
|
|
// out if in front
|
|
bool out= localClipPlanes[j]*_Vertices[vid] > 0;
|
|
|
|
vf|= ((uint)out)<<j;
|
|
}
|
|
|
|
// add the bit flag to say "computed".
|
|
vf|= NL3D_VCM_SHADOW_NUM_CLIP_PLANE_SHIFT;
|
|
|
|
// store
|
|
vertexFlags[vid]= vf;
|
|
}
|
|
|
|
// And all vertex bits.
|
|
triFlag&= vf;
|
|
}
|
|
|
|
// if triangle not clipped, add the triangle
|
|
if( (triFlag & NL3D_VCM_SHADOW_NUM_CLIP_PLANE_MASK)==0 )
|
|
{
|
|
// Add the 3 index to the index buffer.
|
|
ibPtr[currentTriIdx++]= triId[0];
|
|
ibPtr[currentTriIdx++]= triId[1];
|
|
ibPtr[currentTriIdx++]= triId[2];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlassert(iba.getFormat() == CIndexBuffer::Indices16);
|
|
uint16 *ibPtr= (uint16 *) iba.getPtr();
|
|
// for all triangles selected with the quadgrid
|
|
for(uint triq=0; triq<numTrisInQuadGrid;triq++)
|
|
{
|
|
uint triId[3];
|
|
triId[0]= _Triangles[uint(triInQuadGrid[triq])*3+0];
|
|
triId[1]= _Triangles[uint(triInQuadGrid[triq])*3+1];
|
|
triId[2]= _Triangles[uint(triInQuadGrid[triq])*3+2];
|
|
uint triFlag= NL3D_VCM_SHADOW_NUM_CLIP_PLANE_MASK;
|
|
|
|
// for all vertices, clip them
|
|
for(uint i=0;i<3;i++)
|
|
{
|
|
uint vid= triId[i];
|
|
uint vf= vertexFlags[vid];
|
|
|
|
// if this vertex is still not computed
|
|
if(!vf)
|
|
{
|
|
// For all planes of the Clip Volume, clip this vertex.
|
|
for(uint j=0;j<localClipPlanes.size();j++)
|
|
{
|
|
// out if in front
|
|
bool out= localClipPlanes[j]*_Vertices[vid] > 0;
|
|
|
|
vf|= ((uint)out)<<j;
|
|
}
|
|
|
|
// add the bit flag to say "computed".
|
|
vf|= NL3D_VCM_SHADOW_NUM_CLIP_PLANE_SHIFT;
|
|
|
|
// store
|
|
vertexFlags[vid]= vf;
|
|
}
|
|
|
|
// And all vertex bits.
|
|
triFlag&= vf;
|
|
}
|
|
|
|
// if triangle not clipped, add the triangle
|
|
if( (triFlag & NL3D_VCM_SHADOW_NUM_CLIP_PLANE_MASK)==0 )
|
|
{
|
|
// Add the 3 index to the index buffer.
|
|
ibPtr[currentTriIdx++]= (uint16) triId[0];
|
|
ibPtr[currentTriIdx++]= (uint16) triId[1];
|
|
ibPtr[currentTriIdx++]= (uint16) triId[2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// **** Render
|
|
// if some triangle to render
|
|
if(currentTriIdx)
|
|
{
|
|
IDriver *drv= shadowContext.Driver;
|
|
// setup the collision instance matrix
|
|
drv->setupModelMatrix(instanceMatrix);
|
|
// update the material projection matrix, cause matrix changed
|
|
shadowContext.ShadowMapProjector.applyToMaterial(instanceMatrix, shadowContext.ShadowMaterial);
|
|
// render
|
|
drv->activeVertexBuffer(*_VertexBuffer);
|
|
drv->activeIndexBuffer(shadowContext.IndexBuffer);
|
|
drv->renderTriangles(shadowContext.ShadowMaterial, 0, currentTriIdx/3);
|
|
// TestYoyo. Show in Red triangles selected
|
|
/*if(TESTYOYO_VCM_RedShadow)
|
|
{
|
|
static CMaterial tam;
|
|
tam.initUnlit();
|
|
tam.setColor(CRGBA(255,0,0,128));
|
|
tam.setZFunc(CMaterial::always);
|
|
tam.setZWrite(false);
|
|
tam.setBlend(true);
|
|
tam.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
|
|
tam.setDoubleSided(true);
|
|
drv->renderTriangles(tam, 0, currentTriIdx/3);
|
|
}*/
|
|
}
|
|
}
|
|
|
|
|
|
} // NL3D
|