1267 lines
39 KiB
C++
1267 lines
39 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 "stdafx.h" // Precompiled header
|
|
#include "export_nel.h"
|
|
#include "export_appdata.h"
|
|
#include "calc_lm_rt.h"
|
|
|
|
using namespace std;
|
|
using namespace NL3D;
|
|
using namespace NLMISC;
|
|
|
|
|
|
// ***********************************************************************************************
|
|
// CRTWorld
|
|
// ***********************************************************************************************
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTWorld::CRTWorld (bool errorInDialog, bool view, bool absolutePath, Interface *ip, std::string errorTitle, CExportNel *exp)
|
|
{
|
|
_Ip = ip;
|
|
_AbsolutePath = absolutePath;
|
|
_View = view;
|
|
_ErrorInDialog = errorInDialog;
|
|
_ErrorTitle = errorTitle;
|
|
_Export = exp;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTWorld::~CRTWorld()
|
|
{
|
|
uint32 i;
|
|
|
|
for (i = 0; i < vMB.size(); ++i)
|
|
{
|
|
delete vMB[i];
|
|
delete vMBB[i];
|
|
}
|
|
|
|
for (i = 0; i < vLightAccel.size(); ++i)
|
|
if (vLightAccel[i] != NULL)
|
|
delete vLightAccel[i];
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTWorld::build (vector<SLightBuild> &AllLights, CVector &trans, bool bExcludeNonSelected, const set<INode*> &excludeNode, const set<INode*> &includeNode)
|
|
{
|
|
uint32 i, j, k;
|
|
TTicks ttTemp = CTime::getPerformanceTime();
|
|
|
|
DWORD t = timeGetTime();
|
|
|
|
GlobalTrans = trans;
|
|
// Get all the nodes in the scene
|
|
if( bExcludeNonSelected )
|
|
getAllSelectedNode (vMB, vMBB, vINode, AllLights, excludeNode, includeNode);
|
|
else
|
|
getAllNodeInScene (vMB, vMBB, vINode, AllLights, excludeNode);
|
|
|
|
// Transform the meshbuilds vertices and normals to have world coordinates
|
|
for( i = 0; i < vMB.size(); ++i )
|
|
{
|
|
convertToWorldCoordinate (vMB[i], vMBB[i], GlobalTrans);
|
|
}
|
|
|
|
if (InfoLog)
|
|
InfoLog->display("Object Construction : %d ms\n", timeGetTime()-t);
|
|
|
|
// Construct all cube grids from all lights
|
|
//wrt.cgAccel.resize( AllLights.size() );
|
|
//wrt.dirAccel.resize( AllLights.size() );
|
|
|
|
vLight.resize (AllLights.size());
|
|
vLightAccel.resize (AllLights.size());
|
|
|
|
for (i = 0; i < AllLights.size(); ++i)
|
|
{
|
|
SLightBuild &rLight = AllLights[i];
|
|
vLight[i].Position = rLight.Position;
|
|
vLight[i].Direction = rLight.Direction;
|
|
vLight[i].rSoftShadowRadius = rLight.rSoftShadowRadius;
|
|
vLight[i].rSoftShadowConeLength = rLight.rSoftShadowConeLength;
|
|
vLightAccel[i] = NULL;
|
|
|
|
switch (rLight.Type)
|
|
{
|
|
// ------------------------
|
|
case SLightBuild::LightAmbient:
|
|
vLight[i].Type = CRTLight::RTLightAmbient;
|
|
break;
|
|
|
|
// --------------------------
|
|
case SLightBuild::LightSpot: // For the moment spot like point
|
|
vLight[i].Type = CRTLight::RTLightSpot;
|
|
case SLightBuild::LightPoint:
|
|
{
|
|
vLight[i].Type = CRTLight::RTLightPoint;
|
|
CRTLightAccelPoint *pLAP = new CRTLightAccelPoint;
|
|
pLAP->create( 64 ); // width of each grid in number of square
|
|
for( j = 0; j < vMB.size(); ++j )
|
|
{
|
|
if (rLight.setExclusion.find (vINode[j]->GetName()) != rLight.setExclusion.end())
|
|
continue;
|
|
|
|
for (k = 0; k < vMB[j]->Faces.size(); ++k)
|
|
{
|
|
SGridCell cell;
|
|
cell.pF = &(vMB[j]->Faces[k]);
|
|
cell.pMB = vMB[j];
|
|
cell.pMBB = vMBB[j];
|
|
CTriangle tri = CTriangle(
|
|
cell.pMB->Vertices[cell.pF->Corner[0].Vertex] - rLight.Position,
|
|
cell.pMB->Vertices[cell.pF->Corner[1].Vertex] - rLight.Position,
|
|
cell.pMB->Vertices[cell.pF->Corner[2].Vertex] - rLight.Position );
|
|
if (intersectionTriangleSphere (tri, CBSphere(CVector(0,0,0), rLight.rRadiusMax)))
|
|
pLAP->insert( tri, cell );
|
|
}
|
|
}
|
|
vLightAccel[i] = pLAP;
|
|
}
|
|
break;
|
|
|
|
// ------------------------
|
|
case SLightBuild::LightDir:
|
|
{
|
|
vLight[i].Type = CRTLight::RTLightDir;
|
|
CRTLightAccelDir *pLAD = new CRTLightAccelDir;
|
|
pLAD->create (64, rLight.rDirRadius/64.0f, rLight.Direction);
|
|
for( j = 0; j < vMB.size(); ++j )
|
|
{
|
|
if (rLight.setExclusion.find (vINode[j]->GetName()) != rLight.setExclusion.end())
|
|
continue;
|
|
|
|
for (k = 0; k < vMB[j]->Faces.size(); ++k)
|
|
{
|
|
SGridCell cell;
|
|
cell.pF = &(vMB[j]->Faces[k]);
|
|
cell.pMB = vMB[j];
|
|
cell.pMBB = vMBB[j];
|
|
CTriangle tri = CTriangle(
|
|
cell.pMB->Vertices[cell.pF->Corner[0].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[1].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[2].Vertex] );
|
|
// Convert the triangle into a sphere
|
|
CBSphere s;
|
|
s.Center = (tri.V0 + tri.V1 + tri.V2)/3.0f;
|
|
s.Radius = (tri.V0-s.Center).norm();
|
|
float tmp = (tri.V1-s.Center).norm();
|
|
if (tmp > s.Radius) s.Radius = tmp;
|
|
tmp = (tri.V2-s.Center).norm();
|
|
if (tmp > s.Radius) s.Radius = tmp;
|
|
|
|
if (intersectionSphereCylinder (s, rLight.Position, rLight.Direction, rLight.rDirRadius))
|
|
{
|
|
float t = ((s.Center - rLight.Position)*rLight.Direction) / (rLight.Direction*rLight.Direction);
|
|
|
|
if ((t-s.Radius) < pLAD->rMin)
|
|
pLAD->rMin = t - s.Radius;
|
|
|
|
if ((t+s.Radius) > pLAD->rMax)
|
|
pLAD->rMax = t + s.Radius;
|
|
|
|
pLAD->insert (tri, cell);
|
|
}
|
|
}
|
|
}
|
|
vLightAccel[i] = pLAD;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRGBAF CRTWorld::raytrace (NLMISC::CVector &vVertex, sint32 nLightNb, uint8& rtVal, bool bSoftShadow)
|
|
{
|
|
CRGBAF Factor = CRGBAF(1.0f, 1.0f, 1.0f, 1.0f);
|
|
CVector vVertexPos, vLightPos, vSelect;
|
|
|
|
CRTLight &rLight = vLight[nLightNb];
|
|
switch (rLight.Type)
|
|
{
|
|
case SLightBuild::LightAmbient:
|
|
Factor = CRGBAF(1.0f, 1.0f, 1.0f, 1.0f);
|
|
break;
|
|
case SLightBuild::LightSpot:
|
|
case SLightBuild::LightPoint:
|
|
{
|
|
CVector light_p = vVertex - rLight.Position;
|
|
float light_p_distance = light_p.norm();
|
|
light_p_distance = light_p_distance - (0.01f+(0.05f*light_p_distance/100.0f)); // Substract n centimeter
|
|
light_p.normalize();
|
|
light_p *= light_p_distance;
|
|
vLightPos = rLight.Position;
|
|
vVertexPos = rLight.Position + light_p;
|
|
vSelect = vVertexPos - vLightPos;
|
|
}
|
|
break;
|
|
case SLightBuild::LightDir:
|
|
{
|
|
float lightdist = ((vVertex - rLight.Position)*rLight.Direction) / (rLight.Direction.norm());
|
|
CRTLightAccelDir *pLAD = (CRTLightAccelDir*)(vLightAccel[nLightNb]);
|
|
lightdist = lightdist - pLAD->rMin;
|
|
vLightPos = vVertex - rLight.Direction*lightdist;
|
|
vVertexPos = vVertex - (0.01f+(0.05f*lightdist/100.0f))*rLight.Direction;
|
|
vSelect = vVertexPos;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
float rSoftShadowRadius = rLight.rSoftShadowRadius;
|
|
|
|
// Work with the directionnal light only for now
|
|
if ((bSoftShadow) && (rLight.Type == SLightBuild::LightDir))
|
|
{
|
|
CRTRay RayOfLight;
|
|
float rAreaInit;
|
|
|
|
RayOfLight.initDirectionnal(8, vVertex, rLight.Direction, rSoftShadowRadius, rLight.rSoftShadowConeLength);
|
|
rAreaInit = RayOfLight.getArea();
|
|
vLightAccel[nLightNb]->select (vSelect, rSoftShadowRadius);
|
|
while (!vLightAccel[nLightNb]->isEndSel())
|
|
{
|
|
// Get selected element
|
|
SGridCell cell = vLightAccel[nLightNb]->getSel();
|
|
|
|
CTriangle t(cell.pMB->Vertices[cell.pF->Corner[0].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[1].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[2].Vertex] );
|
|
|
|
RayOfLight.clip (t);
|
|
|
|
if (RayOfLight.Shapes.size() == 0)
|
|
return CRGBAF(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
// Next selected element
|
|
vLightAccel[nLightNb]->nextSel();
|
|
}
|
|
|
|
float rVal = RayOfLight.getArea() / rAreaInit; // rVal = AreaNotShadowed / AreaInit
|
|
|
|
return CRGBAF(rVal, rVal, rVal, 255.0f);
|
|
}
|
|
else // Normal shadowing
|
|
{
|
|
vLightAccel[nLightNb]->select (vSelect);
|
|
while (!vLightAccel[nLightNb]->isEndSel())
|
|
{
|
|
// Get selected element
|
|
SGridCell cell = vLightAccel[nLightNb]->getSel();
|
|
|
|
testCell (Factor, cell, vLightPos, vVertexPos, rtVal);
|
|
|
|
if ((Factor.R == 0.0f) &&
|
|
(Factor.G == 0.0f) &&
|
|
(Factor.B == 0.0f))
|
|
return Factor;
|
|
|
|
// Next selected element
|
|
vLightAccel[nLightNb]->nextSel();
|
|
}
|
|
}
|
|
|
|
return Factor;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTWorld::testCell (CRGBAF &retValue, SGridCell &cell, CVector &vLightPos, CVector &vVertexPos, uint8& rtVal)
|
|
{
|
|
CVector hit;
|
|
|
|
CTriangle t(cell.pMB->Vertices[cell.pF->Corner[0].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[1].Vertex],
|
|
cell.pMB->Vertices[cell.pF->Corner[2].Vertex] );
|
|
CPlane plane;
|
|
plane.make( t.V0, t.V1, t.V2 );
|
|
|
|
if( t.intersect( vLightPos, vVertexPos, hit, plane ) )
|
|
{
|
|
if( cell.pMBB->Materials[cell.pF->MaterialId].getBlend() ||
|
|
cell.pMBB->Materials[cell.pF->MaterialId].getAlphaTest() )
|
|
{ // This is a transparent face we have to look in the texture
|
|
ITexture *pT = cell.pMBB->Materials[cell.pF->MaterialId].getTexture(0);
|
|
CRGBAF cPixMap;
|
|
if( pT == NULL )
|
|
{
|
|
retValue *= 1.0f - (cell.pMBB->Materials[cell.pF->MaterialId].getOpacity()/255.0f);
|
|
cPixMap = CRGBAF(1.0f, 1.0f, 1.0f, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
CVector gradU, gradV;
|
|
t.computeGradient( cell.pF->Corner[0].Uvws[0].U,
|
|
cell.pF->Corner[1].Uvws[0].U,
|
|
cell.pF->Corner[2].Uvws[0].U, gradU );
|
|
t.computeGradient( cell.pF->Corner[0].Uvws[0].V,
|
|
cell.pF->Corner[1].Uvws[0].V,
|
|
cell.pF->Corner[2].Uvws[0].V, gradV );
|
|
float u = cell.pF->Corner[0].Uvws[0].U+gradU*(hit-t.V0);
|
|
float v = cell.pF->Corner[0].Uvws[0].V+gradV*(hit-t.V0);
|
|
u = fmodf( u, 1.0f ); if( u < 0.0f ) u += 1.0f;
|
|
v = fmodf( v, 1.0f ); if( v < 0.0f ) v += 1.0f;
|
|
|
|
if( pT->getWidth() == 0 )
|
|
((CTextureFile*)pT)->generate();
|
|
cPixMap = pT->getColor( u,v );
|
|
}
|
|
cPixMap.A *= cell.pMBB->Materials[cell.pF->MaterialId].getOpacity()/255.0f;
|
|
cPixMap.R *= cell.pMBB->Materials[cell.pF->MaterialId].getDiffuse().R/255.0f;
|
|
cPixMap.G *= cell.pMBB->Materials[cell.pF->MaterialId].getDiffuse().G/255.0f;
|
|
cPixMap.B *= cell.pMBB->Materials[cell.pF->MaterialId].getDiffuse().B/255.0f;
|
|
if (cell.pMBB->Materials[cell.pF->MaterialId].getStainedGlassWindow())
|
|
{
|
|
retValue = (1.0f - cPixMap.A)*( retValue*(1.0f-cPixMap.A) +
|
|
retValue*cPixMap*cPixMap.A );
|
|
}
|
|
else
|
|
{
|
|
retValue *= (1.0f - cPixMap.A);
|
|
}
|
|
rtVal = 255;
|
|
}
|
|
else
|
|
{ // This is not a transparent face so if we intersect we get shadow
|
|
if( rtVal < 255 ) rtVal += 1;
|
|
retValue = CRGBAF(0.0f, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTWorld::addNode (INode *pNode, vector< CMesh::CMeshBuild* > &Meshes, vector< CMeshBase::CMeshBaseBuild* > &MeshesBase,
|
|
vector< INode* > &INodes, vector<SLightBuild> &AllLights, const set<INode*> &excludeNode, TimeValue tvTime)
|
|
{
|
|
if (! RPO::isZone (*pNode, tvTime) )
|
|
if (CExportNel::isMesh (*pNode, tvTime))
|
|
{
|
|
// Nel export
|
|
CExportNel exportNel (_ErrorInDialog, _View, true, _Ip, _ErrorTitle, NULL);
|
|
CAABBox aabbox;
|
|
exportNel.buildMeshAABBox(*pNode, aabbox, tvTime);
|
|
aabbox.setCenter(aabbox.getCenter()+GlobalTrans);
|
|
|
|
// Not an excluded node ?
|
|
bool bInteract = false;
|
|
if (excludeNode.find (pNode) == excludeNode.end())
|
|
{
|
|
for( uint32 i = 0; i < AllLights.size(); ++i )
|
|
{
|
|
if( isInteractionWithLight (AllLights[i], aabbox))
|
|
{
|
|
bInteract = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if( bInteract )
|
|
{
|
|
int nAccelType = CExportNel::getScriptAppData (pNode, NEL3D_APPDATA_ACCEL, 32);
|
|
if ((nAccelType&3) == 0) // If not an accelerator
|
|
{
|
|
CMesh::CMeshBuild *pMB;
|
|
CMeshBase::CMeshBaseBuild *pMBB;
|
|
pMB = exportNel.createMeshBuild ( *pNode, tvTime, pMBB);
|
|
if( pMBB->bCastShadows )
|
|
{
|
|
Meshes.push_back( pMB );
|
|
MeshesBase.push_back( pMBB );
|
|
INodes.push_back( pNode );
|
|
}
|
|
else
|
|
{
|
|
delete pMB; // No interaction so delete the mesh
|
|
delete pMBB; // No interaction so delete the mesh
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTWorld::getAllSelectedNode (vector< CMesh::CMeshBuild* > &Meshes,
|
|
vector< CMeshBase::CMeshBaseBuild* > &MeshesBase,
|
|
vector< INode* > &INodes,
|
|
vector<SLightBuild> &AllLights, const set<INode*> &excludeNode, const set<INode*> &includeNode)
|
|
{
|
|
// Get time
|
|
TimeValue tvTime = _Ip->GetTime();
|
|
|
|
// Get node count
|
|
int nNumSelNode = _Ip->GetSelNodeCount();
|
|
// Save all selected objects
|
|
for (int nNode=0; nNode<nNumSelNode; nNode++)
|
|
{
|
|
// Get the node
|
|
INode* pNode = _Ip->GetSelNode (nNode);
|
|
|
|
// Already in the include list ?
|
|
if (includeNode.find (pNode) == includeNode.end())
|
|
{
|
|
// Add the node
|
|
addNode (pNode, Meshes, MeshesBase, INodes, AllLights, excludeNode, tvTime);
|
|
}
|
|
}
|
|
|
|
// Add the included
|
|
set<INode*>::const_iterator ite = includeNode.begin();
|
|
while (ite != includeNode.end())
|
|
{
|
|
// Add the included object
|
|
addNode (*ite, Meshes, MeshesBase, INodes, AllLights, excludeNode, tvTime);
|
|
|
|
// Next node
|
|
ite++;
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTWorld::getAllNodeInScene (vector< CMesh::CMeshBuild* > &Meshes,
|
|
vector< CMeshBase::CMeshBaseBuild* > &BaseMeshes,
|
|
vector< INode* > &INodes,
|
|
vector<SLightBuild> &AllLights, const set<INode*> &excludeNode,
|
|
INode* pNode)
|
|
{
|
|
if( pNode == NULL )
|
|
pNode = _Ip->GetRootNode();
|
|
|
|
// Get a pointer on the object's node
|
|
TimeValue tvTime = _Ip->GetTime();
|
|
|
|
// Add the node
|
|
addNode (pNode, Meshes, BaseMeshes, INodes, AllLights, excludeNode, tvTime);
|
|
|
|
for( sint32 i = 0; i < pNode->NumberOfChildren(); ++i )
|
|
getAllNodeInScene( Meshes, BaseMeshes, INodes, AllLights, excludeNode, pNode->GetChildNode(i) );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTWorld::intersectionTriangleSphere( CTriangle &t, CBSphere &s )
|
|
{
|
|
// if a vertex of the triangle is in the sphere
|
|
CVector v = t.V0 - s.Center;
|
|
float f = v.norm();
|
|
if( f < s.Radius )
|
|
return true;
|
|
v = t.V1 - s.Center;
|
|
f = v.norm();
|
|
if( f < s.Radius )
|
|
return true;
|
|
v = t.V2 - s.Center;
|
|
f = v.norm();
|
|
if( f < s.Radius )
|
|
return true;
|
|
// Ok sonow project the center of the triangle on the plane
|
|
CPlane p;
|
|
p.make( t.V0, t.V1, t.V2 );
|
|
p.normalize();
|
|
|
|
CVector newCenter = p.project( s.Center );
|
|
v = newCenter - s.Center;
|
|
float newRadius = v.norm() / s.Radius;
|
|
if( newRadius > 1.0 )
|
|
newRadius = 1.0;
|
|
newRadius = cosf( newRadius * PI / 2.0f );
|
|
|
|
CVector n = p.getNormal();
|
|
CPlane p2;
|
|
p2.make( t.V0, t.V1, t.V0 + n ); p2.normalize();
|
|
f = p2*newCenter;
|
|
p2.make( t.V1, t.V2, t.V1 + n ); p2.normalize();
|
|
float f2 = p2*newCenter;
|
|
p2.make( t.V2, t.V0, t.V2 + n ); p2.normalize();
|
|
float f3 = p2*newCenter;
|
|
|
|
// Is the newcenter insied the triangle ?
|
|
if( ( f <= 0.0 ) && ( f2 <= 0.0 ) && ( f3 <= 0.0 ) )
|
|
return true;
|
|
if( ( f >= 0.0 ) && ( f2 >= 0.0 ) && ( f3 >= 0.0 ) )
|
|
return true;
|
|
|
|
// Is the newCenter at a distance < newradius from one of the triangle edge ?
|
|
if( ( fabs(f) < newRadius ) || ( fabs(f2) < newRadius ) || ( fabs(f3) < newRadius ) )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTWorld::intersectionSphereCylinder (CBSphere &s, CVector &cyCenter, CVector &cyDir, float cyRadius)
|
|
{
|
|
float t = ((s.Center - cyCenter)*cyDir) / (cyDir*cyDir);
|
|
CVector Xp = cyCenter + t*cyDir;
|
|
float d = (s.Center-Xp).norm();
|
|
if (d <= (cyRadius+s.Radius))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTWorld::isInteractionWithLight (SLightBuild &rSLB, CAABBox &meshBox)
|
|
{
|
|
switch( rSLB.Type )
|
|
{
|
|
case SLightBuild::LightAmbient: // No need an ambient light...
|
|
return false;
|
|
break;
|
|
case SLightBuild::LightSpot: // For the moment spot like point
|
|
case SLightBuild::LightPoint:
|
|
{
|
|
// Get light bbox
|
|
CAABBox lightBox;
|
|
lightBox.setCenter( rSLB.Position );
|
|
lightBox.extend( rSLB.Position - CVector(rSLB.rRadiusMax,0,0) );
|
|
lightBox.extend( rSLB.Position + CVector(rSLB.rRadiusMax,0,0) );
|
|
lightBox.extend( rSLB.Position - CVector(0,rSLB.rRadiusMax,0) );
|
|
lightBox.extend( rSLB.Position + CVector(0,rSLB.rRadiusMax,0) );
|
|
lightBox.extend( rSLB.Position - CVector(0,0,rSLB.rRadiusMax) );
|
|
lightBox.extend( rSLB.Position + CVector(0,0,rSLB.rRadiusMax) );
|
|
|
|
if( lightBox.intersect( meshBox ) )
|
|
return true;
|
|
|
|
if( meshBox.include( lightBox.getMin() ) )
|
|
return true;
|
|
|
|
if( lightBox.include( meshBox.getMin() ) )
|
|
return true;
|
|
}
|
|
break;
|
|
case SLightBuild::LightDir:
|
|
{
|
|
// Use acceleration for dir light to not select all nodes in scene
|
|
CBSphere s;
|
|
s.Radius = meshBox.getHalfSize().norm();
|
|
s.Center = meshBox.getCenter();
|
|
// Test against the cylinder
|
|
if (intersectionSphereCylinder (s, rSLB.Position, rSLB.Direction, rSLB.rDirRadius))
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTWorld::isInteractionLightMesh (SLightBuild &rSLB, NL3D::CMesh::CMeshBuild &rMB, NL3D::CMeshBase::CMeshBaseBuild &rMBB)
|
|
{
|
|
if (rSLB.Type == SLightBuild::LightAmbient)
|
|
return false;
|
|
|
|
// Get the mesh bbox. Warning the vertices need to be transformed.
|
|
CAABBox meshBox;
|
|
CMatrix MBMatrix = getObjectToWorldMatrix (&rMB, &rMBB);
|
|
MBMatrix.movePos (GlobalTrans);
|
|
|
|
for( uint32 j = 0; j < rMB.Vertices.size(); ++j )
|
|
if( j == 0 )
|
|
meshBox.setCenter( MBMatrix * rMB.Vertices[j] );
|
|
else
|
|
meshBox.extend( MBMatrix * rMB.Vertices[j] );
|
|
|
|
return isInteractionWithLight(rSLB, meshBox);
|
|
}
|
|
|
|
|
|
// ***********************************************************************************************
|
|
// Ray representation for soft shadow
|
|
// ***********************************************************************************************
|
|
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTRay::initDirectionnal (uint32 nNbSide, const NLMISC::CVector &vVertex, const NLMISC::CVector &lightDir, float rRadius, float rDistCyl)
|
|
{
|
|
// Construct the matrix with K= vertex to light direction
|
|
CVector vDirection = -lightDir;
|
|
vDirection.normalize();
|
|
CVector I = (fabs(vDirection*CVector(1.f,0,0))>0.99)?CVector(0.f,1.f,0.f):CVector(1.f,0.f,0.f);
|
|
CVector K = vDirection;
|
|
CVector J = K^I;
|
|
J.normalize();
|
|
I=J^K;
|
|
I.normalize();
|
|
|
|
// Setup the Inv Vertex Basis
|
|
_InvVertexMat.identity();
|
|
_InvVertexMat.setRot (I, J, K, true);
|
|
_InvVertexMat.setPos (vVertex);
|
|
_InvVertexMat.invert();
|
|
|
|
// Build the clipping pyramids, in vertex space
|
|
CVector lb(-rRadius, -rRadius, rDistCyl);
|
|
CVector lt(-rRadius, rRadius, rDistCyl);
|
|
CVector rb(rRadius, -rRadius, rDistCyl);
|
|
CVector rt(rRadius, rRadius, rDistCyl);
|
|
// Cone pyramid: perspective and capped at near (for precision and z division) and far (where start the cylinder)
|
|
_ConePyramid[0].make(-CVector::K, CVector(0,0,0.01f)); // near
|
|
_ConePyramid[1].make( CVector::K, CVector(0,0,rDistCyl)); // far
|
|
// NB: don't need the full clip (faster)
|
|
/*_ConePyramid[2].make(CVector::Null, lt, lb); // left
|
|
_ConePyramid[3].make(CVector::Null, rt, lt); // top
|
|
_ConePyramid[4].make(CVector::Null, rb, rt); // right
|
|
_ConePyramid[5].make(CVector::Null, lb, rb); // bottom*/
|
|
// Cylinder pyramid: orthogonal and capped at near (ie rDistCyl, where start the cylinder) only
|
|
_CylinderPyramid[0].make(-CVector::K, CVector(0,0,rDistCyl)); // near
|
|
// NB: don't need the full clip (faster)
|
|
/*_CylinderPyramid[1].make(-CVector::I, lb); // left
|
|
_CylinderPyramid[2].make( CVector::I, rb); // right
|
|
_CylinderPyramid[3].make(-CVector::J, lb); // bottom
|
|
_CylinderPyramid[4].make( CVector::J, lt); // top*/
|
|
|
|
|
|
// Build the initial shape
|
|
Shapes.resize (1);
|
|
SConvexShape &rShp = Shapes[0];
|
|
rShp.Vertices.resize (nNbSide);
|
|
for (uint32 i = 0; i < rShp.Vertices.size(); ++i)
|
|
{
|
|
rShp.Vertices[i].U = rRadius * cosf(i*2.0f*(float)Pi / rShp.Vertices.size());
|
|
rShp.Vertices[i].V = rRadius * sinf(i*2.0f*(float)Pi / rShp.Vertices.size());
|
|
}
|
|
_DistCyl = rDistCyl;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTRay::clip (const CTriangle& t)
|
|
{
|
|
sint i;
|
|
|
|
CVector tv0= _InvVertexMat.mulPoint (t.V0);
|
|
CVector tv1= _InvVertexMat.mulPoint (t.V1);
|
|
CVector tv2= _InvVertexMat.mulPoint (t.V2);
|
|
|
|
|
|
// **** Contribution in the cone part
|
|
nlctassert(NumConePlanes>NumCylinderPlanes);
|
|
CVector apolyIn[3+NumConePlanes];
|
|
CVector apolyOut[3+NumConePlanes];
|
|
CVector *polyIn= apolyIn;
|
|
CVector *polyOut= apolyOut;
|
|
sint numVerts;
|
|
polyIn[0]= tv0;
|
|
polyIn[1]= tv1;
|
|
polyIn[2]= tv2;
|
|
numVerts= 3;
|
|
for(i=0;i<NumConePlanes;i++)
|
|
{
|
|
numVerts= _ConePyramid[i].clipPolygonBack(polyIn, polyOut, numVerts);
|
|
swap(polyIn, polyOut);
|
|
// entirely out
|
|
if(!numVerts)
|
|
break;
|
|
}
|
|
// for all result triangles
|
|
for(i=0;i<numVerts-2;i++)
|
|
{
|
|
CVector v0= polyIn[0];
|
|
CVector v1= polyIn[i+1];
|
|
CVector v2= polyIn[i+2];
|
|
// cone: project at z=distCyl
|
|
v0= v0 * _DistCyl / v0.z;
|
|
v1= v1 * _DistCyl / v1.z;
|
|
v2= v2 * _DistCyl / v2.z;
|
|
|
|
clipProjected(v0,v1,v2);
|
|
}
|
|
|
|
|
|
// **** Contribution in the cylinder part
|
|
polyIn[0]= tv0;
|
|
polyIn[1]= tv1;
|
|
polyIn[2]= tv2;
|
|
numVerts= 3;
|
|
for(i=0;i<NumCylinderPlanes;i++)
|
|
{
|
|
numVerts= _CylinderPyramid[i].clipPolygonBack(polyIn, polyOut, numVerts);
|
|
swap(polyIn, polyOut);
|
|
// entirely out
|
|
if(!numVerts)
|
|
break;
|
|
}
|
|
// for all result triangles
|
|
for(i=0;i<numVerts-2;i++)
|
|
{
|
|
CVector v0= polyIn[0];
|
|
CVector v1= polyIn[i+1];
|
|
CVector v2= polyIn[i+2];
|
|
// cylinder: no projection
|
|
|
|
clipProjected(v0,v1,v2);
|
|
}
|
|
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTRay::clipProjected(const NLMISC::CVector &v0, const NLMISC::CVector &v1, const NLMISC::CVector &v2)
|
|
{
|
|
CUV tri[3];
|
|
|
|
tri[0].U = v0.x; tri[0].V = v0.y;
|
|
tri[1].U = v2.x; tri[1].V = v2.y;
|
|
tri[2].U = v1.x; tri[2].V = v1.y;
|
|
|
|
// Backface swapping
|
|
if (((tri[1].U-tri[0].U) * (tri[2].V-tri[0].V) - (tri[1].V-tri[0].V) * (tri[2].U-tri[0].U)) < 0.0f)
|
|
{
|
|
swap(tri[0],tri[1]);
|
|
}
|
|
|
|
|
|
// **** Clip the convex shapes
|
|
std::vector<SConvexShape> shapesOut;
|
|
for (uint32 i = 0; i < Shapes.size(); ++i)
|
|
{
|
|
SConvexShape &rShp = Shapes[i];
|
|
|
|
// Clip each shapes with the triangle
|
|
if (isShapeMustBeClippedByTriangle (rShp, tri))
|
|
{
|
|
std::vector<SConvexShape> shapesTmp;
|
|
shapesTmp.resize (0);
|
|
clipShape (rShp, tri, shapesTmp);
|
|
for (uint32 j = 0; j < shapesTmp.size(); ++j)
|
|
shapesOut.push_back (shapesTmp[j]);
|
|
}
|
|
else // The shape is not clipped by the triangle so must be add it directly
|
|
{
|
|
shapesOut.push_back (rShp);
|
|
}
|
|
}
|
|
|
|
// We are now like shapesOut
|
|
Shapes = shapesOut;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
float CRTRay::getArea ()
|
|
{
|
|
float rSize = 0.0f;
|
|
|
|
// For all shapes
|
|
for (uint32 i = 0; i < Shapes.size(); ++i)
|
|
{
|
|
SConvexShape &rShp = Shapes[i];
|
|
|
|
// Get all triangles from the shapes
|
|
for (uint32 j = 0; j < rShp.Vertices.size()-2; ++j)
|
|
{
|
|
CUV v1 = rShp.Vertices[j+1] - rShp.Vertices[0];
|
|
CUV v2 = rShp.Vertices[j+2] - rShp.Vertices[0];
|
|
|
|
rSize += 0.5f * fabsf(v1.U*v2.V - v1.V*v2.U);
|
|
}
|
|
}
|
|
|
|
return rSize;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTRay::isShapeMustBeClippedByTriangle (CRTRay::SConvexShape& scs, CUV tri[3])
|
|
{
|
|
uint32 i,j;
|
|
bool bAllVertExt;
|
|
// Is the convex shape vertices are all on a side of the triangle
|
|
for (i = 0; i < 3; ++i)
|
|
{
|
|
CUV &p0 = tri[i];
|
|
CUV &p1 = tri[(i+1)%3];
|
|
bAllVertExt = true;
|
|
for (j = 0; j < scs.Vertices.size(); ++j)
|
|
// Does the vertex j is interior ?
|
|
if (((p1.U-p0.U) * (scs.Vertices[j].V-p0.V) - (p1.V-p0.V) * (scs.Vertices[j].U-p0.U)) > 0.0f)
|
|
{
|
|
bAllVertExt = false; // Yes so all vertex are NOT exterior
|
|
break;
|
|
}
|
|
if (bAllVertExt)
|
|
return false; // Clip not needed because all vertices exterior
|
|
}
|
|
// Is all vertices of the triangle on a side of the convex shape side
|
|
for (i = 0; i < scs.Vertices.size(); ++i)
|
|
{
|
|
CUV &p0 = scs.Vertices[i];
|
|
CUV &p1 = scs.Vertices[(i+1)%scs.Vertices.size()];
|
|
bAllVertExt = true;
|
|
for (j = 0; j < 3; ++j)
|
|
// Does the vertex j is interior ?
|
|
if ((p1.U-p0.U) * (tri[j].V-p0.V) - (p1.V-p0.V) * (tri[j].U-p0.U) > 0.0f)
|
|
{
|
|
bAllVertExt = false; // Yes so all vertex are NOT exterior
|
|
break;
|
|
}
|
|
if (bAllVertExt)
|
|
return false; // Clip not needed because all vertices exterior
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTRay::clipShape (CRTRay::SConvexShape& ShapeIn, CUV Tri[3], vector<CRTRay::SConvexShape> &ShapesOut)
|
|
{
|
|
uint32 i, j, lastj;
|
|
SConvexShape Front, Back, BackInput;
|
|
BackInput = ShapeIn;
|
|
|
|
// For each side of the triangle
|
|
for (i = 0; i < 3; ++i)
|
|
{
|
|
CUV &sideV0 = Tri[i];
|
|
CUV &sideV1 = Tri[(i+1)%3];
|
|
|
|
// Front is the polygon exterior to the side (which does not contain the triangle)
|
|
Front.Vertices.resize (0);
|
|
Back.Vertices.resize (0);
|
|
|
|
lastj = BackInput.Vertices.size()-1;
|
|
bool previousExt = ((sideV1.U-sideV0.U) * (BackInput.Vertices[lastj].V-sideV0.V)
|
|
- (sideV1.V-sideV0.V) * (BackInput.Vertices[lastj].U-sideV0.U) < 0.0f);
|
|
// BackInput -> Back, Front split from the current edge
|
|
for (j = 0; j < BackInput.Vertices.size(); ++j)
|
|
{
|
|
bool currentExt = ((sideV1.U-sideV0.U) * (BackInput.Vertices[j].V-sideV0.V)
|
|
- (sideV1.V-sideV0.V) * (BackInput.Vertices[j].U-sideV0.U) < 0.0f);
|
|
if (currentExt)
|
|
{
|
|
// Vertex j exterior
|
|
if (!previousExt) // Previous vertex interior ?
|
|
{
|
|
// Ok, intersect
|
|
CUV tmp = getLineIntersection (BackInput.Vertices[lastj], BackInput.Vertices[j], sideV0, sideV1);
|
|
Front.Vertices.push_back (tmp);
|
|
Back.Vertices.push_back (tmp);
|
|
}
|
|
// Store new vertex front
|
|
Front.Vertices.push_back (BackInput.Vertices[j]);
|
|
}
|
|
else
|
|
{
|
|
// Vertex j is interior
|
|
if (previousExt) // Previous vertex exterior ?
|
|
{
|
|
// Ok, intersect
|
|
CUV tmp = getLineIntersection (BackInput.Vertices[lastj], BackInput.Vertices[j], sideV0, sideV1);
|
|
Front.Vertices.push_back (tmp);
|
|
Back.Vertices.push_back (tmp);
|
|
}
|
|
// Store new vertex back
|
|
Back.Vertices.push_back (BackInput.Vertices[j]);
|
|
}
|
|
previousExt = currentExt;
|
|
lastj = j;
|
|
}
|
|
|
|
// Run through the front and back to weld vertices
|
|
weldVertices (Front);
|
|
weldVertices (Back);
|
|
|
|
if(Front.Vertices.size() > 2)
|
|
// Front is a poly that we will out
|
|
ShapesOut.push_back (Front);
|
|
|
|
// Get the back poly to the next iteration
|
|
BackInput = Back;
|
|
|
|
if (BackInput.Vertices.size() < 3)
|
|
return;
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTRay::weldVertices (CRTRay::SConvexShape& Shp)
|
|
{
|
|
uint32 curVertex = 0;
|
|
for (uint32 j = 0; j < Shp.Vertices.size(); ++j)
|
|
{
|
|
CUV &p0 = Shp.Vertices[j];
|
|
CUV &p1 = Shp.Vertices[(j+1)%Shp.Vertices.size()];
|
|
if (((p1.U-p0.U)*(p1.U-p0.U)+(p1.V-p0.V)*(p1.V-p0.V)) > 0.0001f)
|
|
{
|
|
Shp.Vertices[curVertex] = p0;
|
|
curVertex++;
|
|
}
|
|
}
|
|
Shp.Vertices.resize (curVertex);
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CUV CRTRay::getLineIntersection (const CUV &l1p1, const CUV &l1p2, const CUV &l2p1, const CUV &l2p2)
|
|
{
|
|
float denominator = (l1p2.U-l1p1.U)*(l2p2.V-l2p1.V) - (l1p2.V-l1p1.V)*(l2p2.U-l2p1.U);
|
|
if (denominator == 0.0)
|
|
return l1p1; // The segment are colinear
|
|
float k = ((l2p1.U-l1p1.U)*(l2p2.V-l2p1.V) - (l2p1.V-l1p1.V)*(l2p2.U-l2p1.U) ) / denominator;
|
|
if (k <= 0.0f)
|
|
return l1p1;
|
|
if (k >= 1.0f)
|
|
return l1p2;
|
|
|
|
return l1p1 + (l1p2-l1p1) * k;
|
|
}
|
|
|
|
// ***********************************************************************************************
|
|
// Light accelerator for directionnal lights
|
|
// ***********************************************************************************************
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTLightAccelDir::CRTLightAccelDir()
|
|
{
|
|
rMin = 100000.0f;
|
|
rMax = -100000.0f;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTLightAccelDir::~CRTLightAccelDir()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelDir::create (int nSize, float rRadius, CVector &vDirection)
|
|
{
|
|
grid.create ( nSize, 2*rRadius );
|
|
|
|
CMatrix tmp;
|
|
CVector I = (fabs(vDirection*CVector(1.f,0,0))>0.99)?CVector(0.f,1.f,0.f):CVector(1.f,0.f,0.f);
|
|
CVector K = vDirection;
|
|
CVector J = K^I;
|
|
J.normalize();
|
|
I=J^K;
|
|
I.normalize();
|
|
|
|
tmp.identity();
|
|
tmp.setRot (I, J, K, true);
|
|
invMat = tmp;
|
|
invMat.invert ();
|
|
|
|
tmp.identity();
|
|
grid.changeBase (tmp);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelDir::insert (CTriangle &tri, SGridCell &cell)
|
|
{
|
|
CVector vMin;
|
|
CVector vMax;
|
|
CTriangle t = tri;
|
|
|
|
t.V0 = invMat.mulPoint (t.V0);
|
|
t.V1 = invMat.mulPoint (t.V1);
|
|
t.V2 = invMat.mulPoint (t.V2);
|
|
|
|
vMin = t.V0; vMax = t.V0;
|
|
|
|
if (vMin.x > t.V1.x) vMin.x = t.V1.x;
|
|
if (vMin.y > t.V1.y) vMin.y = t.V1.y;
|
|
if (vMin.z > t.V1.z) vMin.z = t.V1.z;
|
|
if (vMin.x > t.V2.x) vMin.x = t.V2.x;
|
|
if (vMin.y > t.V2.y) vMin.y = t.V2.y;
|
|
if (vMin.z > t.V2.z) vMin.z = t.V2.z;
|
|
|
|
if (vMax.x < t.V1.x) vMax.x = t.V1.x;
|
|
if (vMax.y < t.V1.y) vMax.y = t.V1.y;
|
|
if (vMax.z < t.V1.z) vMax.z = t.V1.z;
|
|
if (vMax.x < t.V2.x) vMax.x = t.V2.x;
|
|
if (vMax.y < t.V2.y) vMax.y = t.V2.y;
|
|
if (vMax.z < t.V2.z) vMax.z = t.V2.z;
|
|
|
|
grid.insert (vMin, vMax, cell);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelDir::select (CVector &v)
|
|
{
|
|
CVector vSel = v;
|
|
vSel = invMat.mulPoint (vSel);
|
|
grid.select (vSel, vSel);
|
|
itSel = grid.begin();
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelDir::select (CVector &v, float rRadius)
|
|
{
|
|
CVector vSelMin = v, vSelMax;
|
|
vSelMin = invMat.mulPoint (vSelMin);
|
|
vSelMax = vSelMin;
|
|
|
|
vSelMin.x -= sqrtf(2.0f)*rRadius;
|
|
vSelMin.y -= sqrtf(2.0f)*rRadius;
|
|
vSelMax.x += sqrtf(2.0f)*rRadius;
|
|
vSelMax.y += sqrtf(2.0f)*rRadius;
|
|
|
|
grid.select (vSelMin, vSelMax);
|
|
itSel = grid.begin();
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
SGridCell CRTLightAccelDir::getSel ()
|
|
{
|
|
return *itSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelDir::nextSel ()
|
|
{
|
|
++itSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTLightAccelDir::isEndSel ()
|
|
{
|
|
return (itSel == grid.end());
|
|
}
|
|
|
|
// ***********************************************************************************************
|
|
// Light accelerator for point and spot lights
|
|
// ***********************************************************************************************
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTLightAccelPoint::CRTLightAccelPoint ()
|
|
{
|
|
CMatrix tmp;
|
|
CVector I, J, K;
|
|
|
|
// grids[kUp].changeBase( );
|
|
I = CVector( 1, 0, 0 );
|
|
J = CVector( 0, -1, 0 );
|
|
K = CVector( 0, 0, -1 );
|
|
tmp.identity(); tmp.setRot( I, J, K, true );
|
|
_Grids[kDown].changeBase( tmp );
|
|
|
|
I = CVector( 0, 0, 1 );
|
|
J = CVector( 0, 1, 0 );
|
|
K = CVector( -1, 0, 0 );
|
|
tmp.identity(); tmp.setRot( I, J, K, true);
|
|
_Grids[kLeft].changeBase( tmp );
|
|
|
|
I = CVector( 0, 0, -1 );
|
|
J = CVector( 0, 1, 0 );
|
|
K = CVector( 1, 0, 0 );
|
|
tmp.identity(); tmp.setRot( I, J, K, true);
|
|
_Grids[kRight].changeBase( tmp );
|
|
|
|
I = CVector( 1, 0, 0 );
|
|
J = CVector( 0, 0, 1 );
|
|
K = CVector( 0, -1, 0 );
|
|
tmp.identity(); tmp.setRot( I, J, K, true);
|
|
_Grids[kFront].changeBase( tmp );
|
|
|
|
I = CVector( 1, 0, 0 );
|
|
J = CVector( 0, 0, -1 );
|
|
K = CVector( 0, 1, 0 );
|
|
tmp.identity(); tmp.setRot( I, J, K, true);
|
|
_Grids[kBack].changeBase( tmp );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
CRTLightAccelPoint::~CRTLightAccelPoint ()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::create (int nSize)
|
|
{
|
|
_Grids[kUp].create ( nSize, 1.0f / ((float)nSize) );
|
|
_Grids[kDown].create ( nSize, 1.0f / ((float)nSize) );
|
|
_Grids[kLeft].create ( nSize, 1.0f / ((float)nSize) );
|
|
_Grids[kRight].create ( nSize, 1.0f / ((float)nSize) );
|
|
_Grids[kFront].create ( nSize, 1.0f / ((float)nSize) );
|
|
_Grids[kBack].create ( nSize, 1.0f / ((float)nSize) );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::insert (CTriangle &tri, SGridCell &cell)
|
|
{
|
|
CPlane p[4], gp;
|
|
// Construct clip pyramid for grid : UP
|
|
p[0].make( CVector(0,0,0), CVector( -1,-1,+1 ), CVector( +1,-1,+1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( +1,-1,+1 ), CVector( +1,+1,+1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( +1,+1,+1 ), CVector( -1,+1,+1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( -1,+1,+1 ), CVector( -1,-1,+1 ) );
|
|
gp.make( CVector(0,0,1), CVector(0,0,0.5) );
|
|
project( tri, p, gp, kUp, cell );
|
|
// Construct clip pyramid for grid : DOWN
|
|
p[0].make( CVector(0,0,0), CVector( +1,-1,-1 ), CVector( -1,-1,-1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( -1,-1,-1 ), CVector( -1,+1,-1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( -1,+1,-1 ), CVector( +1,+1,-1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( +1,+1,-1 ), CVector( +1,-1,-1 ) );
|
|
gp.make( CVector(0,0,-1), CVector(0,0,-0.5) );
|
|
project( tri, p, gp, kDown, cell );
|
|
// Construct clip pyramid for grid : LEFT
|
|
p[0].make( CVector(0,0,0), CVector( -1,-1,-1 ), CVector( -1,-1,+1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( -1,-1,+1 ), CVector( -1,+1,+1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( -1,+1,+1 ), CVector( -1,+1,-1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( -1,+1,-1 ), CVector( -1,-1,-1 ) );
|
|
gp.make( CVector(-1,0,0), CVector(-0.5,0,0) );
|
|
project( tri, p, gp, kLeft, cell );
|
|
// Construct clip pyramid for grid : RIGHT
|
|
p[0].make( CVector(0,0,0), CVector( +1,-1,+1 ), CVector( +1,-1,-1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( +1,-1,-1 ), CVector( +1,+1,-1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( +1,+1,-1 ), CVector( +1,+1,+1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( +1,+1,+1 ), CVector( +1,-1,+1 ) );
|
|
gp.make( CVector(1,0,0), CVector(0.5,0,0) );
|
|
project( tri, p, gp, kRight, cell );
|
|
// Construct clip pyramid for grid : FRONT
|
|
p[0].make( CVector(0,0,0), CVector( -1,-1,-1 ), CVector( +1,-1,-1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( +1,-1,-1 ), CVector( +1,-1,+1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( +1,-1,+1 ), CVector( -1,-1,+1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( -1,-1,+1 ), CVector( -1,-1,-1 ) );
|
|
gp.make( CVector(0,-1,0), CVector(0,-0.5,0) );
|
|
project( tri, p, gp, kFront, cell );
|
|
// Construct clip pyramid for grid : BACK
|
|
p[0].make( CVector(0,0,0), CVector( +1,+1,+1 ), CVector( +1,+1,-1 ) );
|
|
p[1].make( CVector(0,0,0), CVector( +1,+1,-1 ), CVector( -1,+1,-1 ) );
|
|
p[2].make( CVector(0,0,0), CVector( -1,+1,-1 ), CVector( -1,+1,+1 ) );
|
|
p[3].make( CVector(0,0,0), CVector( -1,+1,+1 ), CVector( +1,+1,+1 ) );
|
|
gp.make( CVector(0,1,0), CVector(0,0.5,0) );
|
|
project( tri, p, gp, kBack, cell );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::select (CVector &v)
|
|
{
|
|
SSelector sel;
|
|
CPlane gp;
|
|
// Get the plane
|
|
if( ( -v.z <= v.x ) && ( v.x <= v.z ) &&
|
|
( -v.z <= v.y ) && ( v.y <= v.z ) &&
|
|
( 0.0f <= v.z ) )
|
|
{
|
|
sel.nSelGrid = kUp;
|
|
gp.make( CVector(0,0,1), CVector(0,0,0.5) );
|
|
}
|
|
if( ( v.z <= v.x ) && ( v.x <= -v.z ) &&
|
|
( v.z <= v.y ) && ( v.y <= -v.z ) &&
|
|
( v.z <= 0.0f ) )
|
|
{
|
|
sel.nSelGrid = kDown;
|
|
gp.make( CVector(0,0,-1), CVector(0,0,-0.5) );
|
|
}
|
|
if( ( v.x <= 0.0f ) &&
|
|
( v.x <= v.y ) && ( v.y <= -v.x ) &&
|
|
( v.x <= v.z ) && ( v.z <= -v.x ) )
|
|
{
|
|
sel.nSelGrid = kLeft;
|
|
gp.make( CVector(-1,0,0), CVector(-0.5,0,0) );
|
|
}
|
|
if( ( 0.0f <= v.x ) &&
|
|
( -v.x <= v.y ) && ( v.y <= v.x ) &&
|
|
( -v.x <= v.z ) && ( v.z <= v.x ) )
|
|
{
|
|
sel.nSelGrid = kRight;
|
|
gp.make( CVector(1,0,0), CVector(0.5,0,0) );
|
|
}
|
|
if( ( v.y <= v.x ) && ( v.x <= -v.y ) &&
|
|
( v.y <= 0.0f ) &&
|
|
( v.y <= v.z ) && ( v.z <= -v.y ) )
|
|
{
|
|
sel.nSelGrid = kFront;
|
|
gp.make( CVector(0,-1,0), CVector(0,-0.5,0) );
|
|
}
|
|
if( ( -v.y <= v.x ) && ( v.x <= v.y ) &&
|
|
( 0.0f <= v.y ) &&
|
|
( -v.y <= v.z ) && ( v.z <= v.y ) )
|
|
{
|
|
sel.nSelGrid = kBack;
|
|
gp.make( CVector(0,1,0), CVector(0,0.5,0) );
|
|
}
|
|
nlassert(sel.nSelGrid!=-1);
|
|
CVector newV = gp.intersect( CVector(0,0,0), v );
|
|
_Grids[sel.nSelGrid].select(newV, newV);
|
|
sel.itSel = _Grids[sel.nSelGrid].begin();
|
|
_Selection.clear();
|
|
_Selection.push_back (sel);
|
|
_CurSel = 0; // Point on the first non-empty grid
|
|
while ( (_CurSel < _Selection.size()) &&
|
|
(_Selection[_CurSel].itSel == _Grids[_Selection[_CurSel].nSelGrid].end()) )
|
|
++_CurSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::select (CVector &v, float rRadius)
|
|
{
|
|
// Perpendicular projection of the circle on each plane
|
|
|
|
|
|
// TODO
|
|
|
|
// TODO
|
|
|
|
_CurSel = 0; // Point on the first non-empty grid
|
|
while ( (_CurSel < _Selection.size()) &&
|
|
(_Selection[_CurSel].itSel == _Grids[_Selection[_CurSel].nSelGrid].end()) )
|
|
++_CurSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
SGridCell CRTLightAccelPoint::getSel ()
|
|
{
|
|
return *_Selection[_CurSel].itSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::nextSel ()
|
|
{
|
|
++(_Selection[_CurSel].itSel);
|
|
while ( (_CurSel < _Selection.size()) &&
|
|
(_Selection[_CurSel].itSel == _Grids[_Selection[_CurSel].nSelGrid].end()) )
|
|
++_CurSel;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
bool CRTLightAccelPoint::isEndSel ()
|
|
{
|
|
return (_CurSel == _Selection.size());
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
void CRTLightAccelPoint::project (CTriangle &tri, CPlane pyr[4], CPlane &gridPlane, sint32 nGridNb, SGridCell &cell)
|
|
{
|
|
CVector vIn[7], vOut[7];
|
|
sint32 i, nOut;
|
|
vIn[0] = tri.V0; vIn[1] = tri.V1; vIn[2] = tri.V2;
|
|
nOut = pyr[0].clipPolygonFront( vIn, vOut, 3 );
|
|
if( nOut == 0 ) return;
|
|
for( i = 0; i < nOut; ++i ) vIn[i] = vOut[i];
|
|
nOut = pyr[1].clipPolygonFront( vIn, vOut, nOut );
|
|
if( nOut == 0 ) return;
|
|
for( i = 0; i < nOut; ++i ) vIn[i] = vOut[i];
|
|
nOut = pyr[2].clipPolygonFront( vIn, vOut, nOut );
|
|
if( nOut == 0 ) return;
|
|
for( i = 0; i < nOut; ++i ) vIn[i] = vOut[i];
|
|
nOut = pyr[3].clipPolygonFront( vIn, vOut, nOut );
|
|
if( nOut >= 3 )
|
|
{
|
|
CVector vMin(1, 1, 1), vMax(-1, -1, -1);
|
|
for( i = 0; i < nOut; ++i )
|
|
{
|
|
vOut[i] = gridPlane.intersect( CVector(0, 0, 0), vOut[i] );
|
|
if( vMin.x > vOut[i].x ) vMin.x = vOut[i].x;
|
|
if( vMin.y > vOut[i].y ) vMin.y = vOut[i].y;
|
|
if( vMin.z > vOut[i].z ) vMin.z = vOut[i].z;
|
|
if( vMax.x < vOut[i].x ) vMax.x = vOut[i].x;
|
|
if( vMax.y < vOut[i].y ) vMax.y = vOut[i].y;
|
|
if( vMax.z < vOut[i].z ) vMax.z = vOut[i].z;
|
|
}
|
|
// Create the bbox
|
|
_Grids[nGridNb].insert( vMin, vMax, cell );
|
|
}
|
|
}
|
|
|