mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-15 14:08:42 +00:00
383 lines
12 KiB
C++
383 lines
12 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_manager.h"
|
|
#include "nel/3d/visual_collision_entity.h"
|
|
#include "nel/3d/landscape.h"
|
|
#include "nel/3d/camera_col.h"
|
|
#include "nel/3d/shadow_map.h"
|
|
#include "nel/3d/light.h"
|
|
#include "nel/misc/common.h"
|
|
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
// ***************************************************************************
|
|
// Those blocks size are computed to be approximatively one block for 10 entities.
|
|
const uint TileDescNodeAllocatorBlockSize= 40000;
|
|
const uint PatchQuadBlockAllocatorBlockSize= 160;
|
|
// For Mesh QuadGrid
|
|
const uint MeshColQuadGridSize= 64;
|
|
const float MeshColQuadGridEltSize= 20;
|
|
|
|
|
|
// ***************************************************************************
|
|
CVisualCollisionManager::CVisualCollisionManager() :
|
|
_TileDescNodeAllocator(TileDescNodeAllocatorBlockSize),
|
|
_PatchQuadBlockAllocator(PatchQuadBlockAllocatorBlockSize)
|
|
{
|
|
_Landscape= NULL;
|
|
|
|
// Default.
|
|
setSunContributionPower(0.5f, 0.5f);
|
|
|
|
// init the mesh quadGrid
|
|
_MeshQuadGrid.create(MeshColQuadGridSize, MeshColQuadGridEltSize);
|
|
// valid id start at 1
|
|
_MeshIdPool= 1;
|
|
|
|
_PlayerInside= false;
|
|
_ShadowIndexBuffer.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
|
|
NL_SET_IB_NAME(_ShadowIndexBuffer, "CVisualCollisionManager");
|
|
}
|
|
// ***************************************************************************
|
|
CVisualCollisionManager::~CVisualCollisionManager()
|
|
{
|
|
_Landscape= NULL;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::setLandscape(CLandscape *landscape)
|
|
{
|
|
_Landscape= landscape;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CVisualCollisionEntity *CVisualCollisionManager::createEntity()
|
|
{
|
|
return new CVisualCollisionEntity(this);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::deleteEntity(CVisualCollisionEntity *entity)
|
|
{
|
|
delete entity;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CVisualTileDescNode *CVisualCollisionManager::newVisualTileDescNode()
|
|
{
|
|
return _TileDescNodeAllocator.allocate();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::deleteVisualTileDescNode(CVisualTileDescNode *ptr)
|
|
{
|
|
_TileDescNodeAllocator.free(ptr);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
CPatchQuadBlock *CVisualCollisionManager::newPatchQuadBlock()
|
|
{
|
|
return _PatchQuadBlockAllocator.allocate();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::deletePatchQuadBlock(CPatchQuadBlock *ptr)
|
|
{
|
|
_PatchQuadBlockAllocator.free(ptr);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::setSunContributionPower(float power, float maxThreshold)
|
|
{
|
|
NLMISC::clamp(power, 0.f, 1.f);
|
|
|
|
for(uint i=0; i<256; i++)
|
|
{
|
|
float f= i/255.f;
|
|
f = powf(f/maxThreshold, power);
|
|
sint uf= (sint)floor(255*f);
|
|
NLMISC::clamp(uf, 0, 255);
|
|
_SunContributionLUT[i]= uf;
|
|
}
|
|
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// Camera collision
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::setPlayerInside(bool state)
|
|
{
|
|
_PlayerInside= state;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
float CVisualCollisionManager::getCameraCollision(const CVector &start, const CVector &end, float radius, bool cone)
|
|
{
|
|
float minCol= 1;
|
|
|
|
// try col with landscape
|
|
if(_Landscape)
|
|
{
|
|
minCol= _Landscape->getCameraCollision(start, end, radius, cone);
|
|
}
|
|
|
|
// try col with meshes
|
|
CCameraCol camCol;
|
|
camCol.build(start, end, radius, cone);
|
|
_MeshQuadGrid.select(camCol.getBBox().getMin(), camCol.getBBox().getMax());
|
|
// try to intersect with any instance meshs
|
|
CQuadGrid<CMeshInstanceCol*>::CIterator it;
|
|
for(it= _MeshQuadGrid.begin();it!=_MeshQuadGrid.end();it++)
|
|
{
|
|
// Skip this mesh according to special flag (IBBR problem)
|
|
if((*it)->AvoidCollisionWhenPlayerInside && _PlayerInside)
|
|
continue;
|
|
if((*it)->AvoidCollisionWhenPlayerOutside && !_PlayerInside)
|
|
continue;
|
|
|
|
// collide
|
|
float meshCol= (*it)->getCameraCollision(camCol);
|
|
// Keep only yhe smallest value
|
|
minCol= min(minCol, meshCol);
|
|
}
|
|
|
|
return minCol;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CVisualCollisionManager::getRayCollision(const NLMISC::CVector &start, const NLMISC::CVector &end, bool landscapeOnly)
|
|
{
|
|
// try col with landscape
|
|
if(_Landscape)
|
|
{
|
|
if( _Landscape->getRayCollision(start, end) < 1.f)
|
|
return true;
|
|
}
|
|
|
|
// try col with meshes, if wanted
|
|
if(!landscapeOnly)
|
|
{
|
|
CCameraCol camCol;
|
|
camCol.buildRay(start, end);
|
|
_MeshQuadGrid.select(camCol.getBBox().getMin(), camCol.getBBox().getMax());
|
|
// try to intersect with any instance meshs
|
|
CQuadGrid<CMeshInstanceCol*>::CIterator it;
|
|
for(it= _MeshQuadGrid.begin();it!=_MeshQuadGrid.end();it++)
|
|
{
|
|
// Skip this mesh according to special flag (IBBR problem)
|
|
if((*it)->AvoidCollisionWhenPlayerInside && _PlayerInside)
|
|
continue;
|
|
if((*it)->AvoidCollisionWhenPlayerOutside && !_PlayerInside)
|
|
continue;
|
|
|
|
// collide
|
|
float meshCol= (*it)->getCameraCollision(camCol);
|
|
if(meshCol<1.f)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
float CVisualCollisionManager::CMeshInstanceCol::getCameraCollision(CCameraCol &camCol)
|
|
{
|
|
// if mesh still present (else it s may be an error....)
|
|
if(Mesh)
|
|
{
|
|
// first test if intersect with the bboxes
|
|
if(!camCol.getBBox().intersect(WorldBBox))
|
|
return 1;
|
|
|
|
// get the collision with the mesh
|
|
return Mesh->getCameraCollision(WorldMatrix, camCol);
|
|
}
|
|
else
|
|
// no collision
|
|
return 1;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
uint CVisualCollisionManager::addMeshInstanceCollision(CVisualCollisionMesh *mesh, const CMatrix &instanceMatrix, bool avoidCollisionWhenInside, bool avoidCollisionWhenOutside)
|
|
{
|
|
if(!mesh)
|
|
return 0;
|
|
|
|
// allocate a new id
|
|
uint32 id= _MeshIdPool++;
|
|
|
|
// insert in map
|
|
CMeshInstanceCol &meshInst= _Meshs[id];
|
|
|
|
// Build the col mesh instance
|
|
meshInst.Mesh= mesh;
|
|
meshInst.WorldMatrix= instanceMatrix;
|
|
meshInst.WorldBBox= mesh->computeWorldBBox(instanceMatrix);
|
|
meshInst.AvoidCollisionWhenPlayerInside= avoidCollisionWhenInside;
|
|
meshInst.AvoidCollisionWhenPlayerOutside= avoidCollisionWhenOutside;
|
|
meshInst.ID = id;
|
|
|
|
// insert in quadGrid
|
|
meshInst.QuadGridIt= _MeshQuadGrid.insert(meshInst.WorldBBox.getMin(), meshInst.WorldBBox.getMax(), &meshInst);
|
|
|
|
return id;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::removeMeshCollision(uint id)
|
|
{
|
|
// find in map
|
|
TMeshColMap::iterator it= _Meshs.find(id);
|
|
if(it!=_Meshs.end())
|
|
{
|
|
// remove from the quadgrid
|
|
_MeshQuadGrid.erase(it->second.QuadGridIt);
|
|
// remove from the map
|
|
_Meshs.erase(it);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::receiveShadowMap(IDriver *drv, CShadowMap *shadowMap, const CVector &casterPos, CMaterial &shadowMat, CShadowMapProjector &smp)
|
|
{
|
|
// Build a shadow context
|
|
CVisualCollisionMesh::CShadowContext shadowContext(shadowMat, _ShadowIndexBuffer, smp);
|
|
shadowContext.Driver= drv;
|
|
shadowContext.ShadowMap= shadowMap;
|
|
shadowContext.CasterPos= casterPos;
|
|
shadowContext.ShadowWorldBB= shadowMap->LocalBoundingBox;
|
|
shadowContext.ShadowWorldBB.setCenter(shadowContext.ShadowWorldBB.getCenter() + casterPos);
|
|
|
|
// bkup shadowColor
|
|
CRGBA shadowColor= shadowContext.ShadowMaterial.getColor();
|
|
|
|
// try to intersect with any instance meshs in quadgrid
|
|
_MeshQuadGrid.select(shadowContext.ShadowWorldBB.getMin(), shadowContext.ShadowWorldBB.getMax());
|
|
CQuadGrid<CMeshInstanceCol*>::CIterator it;
|
|
bool lightSetupFaked= false;
|
|
for(it= _MeshQuadGrid.begin();it!=_MeshQuadGrid.end();it++)
|
|
{
|
|
/* NB: this is a collision flag, but the problem is exactly the same for shadows:
|
|
If the player is outside, then an "outside entity" can cast shadow only on "outside mesh"
|
|
*/
|
|
// Skip this mesh according to special flag (IBBR problem)
|
|
if((*it)->AvoidCollisionWhenPlayerInside && _PlayerInside)
|
|
continue;
|
|
if((*it)->AvoidCollisionWhenPlayerOutside && !_PlayerInside)
|
|
continue;
|
|
|
|
|
|
/* Avoid BackFace Shadowing on CVisualCollisionMesh. To do this simply and smoothly, use a trick:
|
|
Use a FakeLight: a directional light in reverse direction of the shadow direction
|
|
The material is now a lighted material, with
|
|
Emissive= ShadowColor so we get correct dark color, for frontfaces agst shadow direction
|
|
(which are actually backfaces agst FakeLight)
|
|
Diffuse= White so shadow is off, for pure backFace agst shadow direction
|
|
(which are actually frontFaces agst FakeLight)
|
|
NB: CShadowMapManager::renderProject() has called CRenderTrav::resetLighting() and enableLight(0, true) so we get clean setup here
|
|
*/
|
|
// need to do it only one time per shadowMap reception
|
|
if(!lightSetupFaked)
|
|
{
|
|
lightSetupFaked= true;
|
|
// Build the light direction as the opposite to shadow direction (in LocalProjectionMatrix.getJ())
|
|
CLight fakeLight;
|
|
fakeLight.setupDirectional(CRGBA::Black, CRGBA::White, CRGBA::Black, -shadowMap->LocalProjectionMatrix.getJ());
|
|
drv->setLight(0, fakeLight);
|
|
// setup the material
|
|
shadowContext.ShadowMaterial.setLighting(true, shadowColor, CRGBA::Black, CRGBA::White, CRGBA::Black);
|
|
}
|
|
|
|
// cast shadow
|
|
(*it)->receiveShadowMap(shadowContext);
|
|
}
|
|
|
|
// if the material has been faked, reset
|
|
if(lightSetupFaked)
|
|
{
|
|
shadowContext.ShadowMaterial.setLighting(false);
|
|
shadowContext.ShadowMaterial.setColor(shadowColor);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::CMeshInstanceCol::receiveShadowMap(const CVisualCollisionMesh::CShadowContext &shadowContext)
|
|
{
|
|
// if mesh still present (else it s may be an error....)
|
|
if(Mesh)
|
|
{
|
|
// first test if intersect with the bboxes
|
|
if(!shadowContext.ShadowWorldBB.intersect(WorldBBox))
|
|
return;
|
|
|
|
// get the collision with the mesh
|
|
Mesh->receiveShadowMap(WorldMatrix, shadowContext);
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CVisualCollisionManager::getMeshs(const NLMISC::CAABBox &aabbox, std::vector<CMeshInstanceColInfo> &dest)
|
|
{
|
|
_MeshQuadGrid.select(aabbox.getMin(), aabbox.getMax());
|
|
dest.clear();
|
|
CQuadGrid<CMeshInstanceCol*>::CIterator it = _MeshQuadGrid.begin();
|
|
CQuadGrid<CMeshInstanceCol*>::CIterator endIt = _MeshQuadGrid.end();
|
|
while (it != endIt)
|
|
{
|
|
if ((*it)->WorldBBox.intersect(aabbox))
|
|
{
|
|
CMeshInstanceColInfo infos;
|
|
infos.Mesh = (*it)->Mesh;
|
|
infos.ID = (*it)->ID;
|
|
infos.WorldBBox = &((*it)->WorldBBox);
|
|
infos.WorldMatrix = &((*it)->WorldMatrix);
|
|
dest.push_back(infos);
|
|
}
|
|
++ it;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
} // NL3D
|
|
|