Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/tools/3d/plugin_max/nel_export/nel_export_lightmap_v2.cpp

3824 lines
121 KiB
C++
Raw Blame History

// --------------------
// LIGHTMAP CALCULATION
// --------------------
// OLD VERSION
// This version handled a group of object at one time to optimize the precalculation
// of the accelerated world raytrace structure
#include "nel/misc/time_nl.h"
#include "nel/misc/file.h"
#include "nel/misc/triangle.h"
#include "nel/misc/bsphere.h"
#include "3d/quad_tree.h"
#include "3d/skeleton_shape.h"
#include "3d/texture_file.h"
#include "3d/light.h"
#include "nel_export_scene.h"
#include "3d/bsp_tree.h"
#include "3d/quad_grid.h"
// TOOLS
// *****
#define NEL_LIGHT_CLASS_ID_A 0x36e3181f
#define NEL_LIGHT_CLASS_ID_B 0x3ac24049
#define MAXLIGHTMAPSIZE 1024
//#define RATIOLIGHTMAP 0.25 // 0.25 meters in real world represent 1 Lumel in UV world
// -----------------------------------------------------------------------------------------------
struct SLightBuild
{
string GroupName;
enum EType { LightAmbient, LightPoint, LightDir, LightSpot };
EType Type;
CVector Position; // Used by LightPoint and LightSpot
CVector Direction; // Used by LightSpot and LightDir
float rRadiusMin, rRadiusMax; // Used by LightPoint and LightSpot
float rHotspot, rFallof; // Used by LightSpot
CRGBA Ambient;
CRGBA Diffuse;
CRGBA Specular;
bool bAnimate;
bool bCastShadow;
float rMult;
// ------------------------------------
SLightBuild()
{
Type = LightPoint;
Position = CVector(0.0, 0.0, 0.0);
Direction = CVector(1.0, 0.0, 0.0);
rRadiusMin = 1.0f;
rRadiusMax = 2.0f;
Ambient = CRGBA(0, 0, 0, 0);
Diffuse = CRGBA(0, 0, 0, 0);
Specular = CRGBA(0, 0, 0, 0);
bAnimate = false; // TEMP MAT
rMult = 1.0f;
}
};
// -----------------------------------------------------------------------------------------------
struct SLMPixel
{
CRGBAF p[8]; // 8 Layers of lightmap possible
};
// -----------------------------------------------------------------------------------------------
struct SLMPlane
{
sint32 x, y; // Pos in lightmap
sint32 w, h; // Size
vector<uint8> msk; // 0 - No pixel
// 1 - Pixel must be calculated
// 2 - Pixel is interior and is calculated
// 3 - Pixel is exterior in this plane but interior in another of the same smooth group
// 4 - Pixel is exterior and is extrapolated
vector<SLMPixel> col; // 32 bits value for each pixel of each layer
sint32 nNbLayerUsed;
vector<CMesh::CFace*> faces;
// ------------------------------------
SLMPlane()
{
nNbLayerUsed = 0;
x = y = 0; w = h = 1; msk.resize(1); msk[0] = 0;
col.resize(1);
for( sint32 i = 0; i < 8; ++i )
{ col[0].p[i].R = col[0].p[i].G = col[0].p[i].B = col[0].p[i].A = 0.0f; }
}
};
// -----------------------------------------------------------------------------------------------
struct SGradient
{
// Vertex gradient
double InitPx, InitPy, InitPz;
double GraduPx, GradvPx;
double GraduPy, GradvPy;
double GraduPz, GradvPz;
// Normal gradient
double InitNx, InitNy, InitNz;
double GraduNx, GradvNx;
double GraduNy, GradvNy;
double GraduNz, GradvNz;
// Initial u,v
double InitU, InitV;
};
// -----------------------------------------------------------------------------------------------
struct SCubeGridCell
{
CMesh::CFace* pF;
CMesh::CMeshBuild* pMB;
};
// -----------------------------------------------------------------------------------------------
// Represent a cube made of grids centered on (0,0,0) with a size of 1
struct SCubeGrid
{
enum gridPos { kUp = 0, kDown, kLeft, kRight, kFront, kBack };
CQuadGrid<SCubeGridCell> grids[6];
sint32 nSelGrid;
CQuadGrid<SCubeGridCell>::CIterator itSel;
// =======================================================================
SCubeGrid()
{
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 );
}
// =======================================================================
void 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 project( CTriangle &tri, CPlane pyr[4], CPlane &gridPlane,
sint32 nGridNb, SCubeGridCell &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 );
}
}
// =======================================================================
void insert( CTriangle &tri, SCubeGridCell &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 select( CVector &v )
{
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 ) )
{
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 ) )
{
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 ) )
{
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 ) )
{
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 ) )
{
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 ) )
{
nSelGrid = kBack;
gp.make( CVector(0,1,0), CVector(0,0.5,0) );
}
nlassert(nSelGrid!=-1);
CVector newV = gp.intersect( CVector(0,0,0), v );
grids[nSelGrid].select(newV, newV);
itSel = grids[nSelGrid].begin();
}
SCubeGridCell getSel()
{
return *itSel;
}
void nextSel()
{
++itSel;
}
bool isEndSel()
{
return (itSel == grids[nSelGrid].end());
}
};
// -----------------------------------------------------------------------------------------------
struct SWorldRT
{
vector<CMesh::CMeshBuild *> vMB;
vector<SCubeGrid> cgAccel; // One cube grid by light
// vector<CAABBox> bbBoxes;
// vector<sint32> MeshSel;
// vector<CQuadTree<SWorldRTCell> > qtAccel;
// vector<CBSPTree<SWorldRTCell> > btAccel;
};
TTicks timerCalcRT = 0;
TTicks timerExportLighting = 0;
TTicks timerInit = 0;
TTicks timerCalc = 0;
TTicks timerPlac = 0;
TTicks timerSave = 0;
// -----------------------------------------------------------------------------------------------
void SortFaceByTextureName(vector<CMesh::CFace*> &AllFaces, CMesh::CMeshBuild *pMB)
{
int i, j;
int nNbFace = AllFaces.size();
for( i = 0; i < nNbFace-1; ++i )
for( j = i+1; j < nNbFace; ++j )
{
ITexture *pT = pMB->Materials[AllFaces[i]->MaterialId].getTexture(0);
CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
string namei = "Default";
if( pTF != NULL )
namei = pTF->getFileName();
pT = pMB->Materials[AllFaces[j]->MaterialId].getTexture(0);
pTF = dynamic_cast<CTextureFile *>(pT);
string namej = "Default";
if( pTF != NULL )
namej = pTF->getFileName();
if( namei < namej )
{
CMesh::CFace *pFaceTemp = AllFaces[i];
AllFaces[i] = AllFaces[j];
AllFaces[j] = pFaceTemp;
}
}
}
// -----------------------------------------------------------------------------------------------
// TextureNames is an array which indicates the number of faces that follows which have the same texture name
void ComputeAreaOfTextureName(vector<sint32> &TextureNames, vector<CMesh::CFace*> &AllFaces, CMesh::CMeshBuild *pMB)
{
int i, nNbFace = AllFaces.size();
TextureNames.resize(nNbFace);
ITexture *pT = pMB->Materials[AllFaces[0]->MaterialId].getTexture(0);
CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
string CurrentName = "Default";
sint32 lastface = 0, nNbTexName = 0;
if( pTF != NULL )
CurrentName = pTF->getFileName();
for( i = 0; i < nNbFace; ++i )
{
ITexture *pT = pMB->Materials[AllFaces[i]->MaterialId].getTexture(0);
CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
string namei = "Default";
if( pTF != NULL )
namei = pTF->getFileName();
if( ( namei != CurrentName ) || ( i == (nNbFace-1) ) )
{
CurrentName = namei;
TextureNames[nNbTexName] = i-lastface;
nNbTexName++;
lastface = i;
}
}
TextureNames[nNbTexName-1] += 1;
TextureNames.resize( nNbTexName );
}
// -----------------------------------------------------------------------------------------------
void SortFaceByMaterialId( vector<sint32> &FaceGroup, vector<CMesh::CFace*>::iterator ItFaces, sint32 nNbFace )
{
int i, j;
sint32 nMatID;
// Bubble sort face
vector<CMesh::CFace*>::iterator ItParseI = ItFaces;
for( i = 0; i < nNbFace-1; ++i )
{
vector<CMesh::CFace*>::iterator ItParseJ = ItParseI;
++ItParseJ;
for( j = i+1; j < nNbFace; ++j )
{
if( (*ItParseI)->MaterialId < (*ItParseJ)->MaterialId )
{
CMesh::CFace *pFaceTemp = *ItParseI;
*ItParseI = *ItParseJ;
*ItParseJ = pFaceTemp;
}
++ItParseJ;
}
++ItParseI;
}
// Indicates the groups
FaceGroup.resize( nNbFace );
ItParseI = ItFaces;
j = 0; nMatID = (*ItParseI)->MaterialId; ++ItParseI;
FaceGroup[j] = 1;
for( i = 1; i < nNbFace; ++i )
{
if( (*ItParseI)->MaterialId != nMatID )
{
nMatID = (*ItParseI)->MaterialId; ++j;
FaceGroup[j] = 1;
}
else
{
FaceGroup[j] ++;
}
++ItParseI;
}
FaceGroup.resize( j+1 );
}
// -----------------------------------------------------------------------------------------------
// Test if the 2 faces are continuous (same vertex, same normal (if wanted), same uv (if wanted))
bool FaceContinuous( CMesh::CFace *pF1, CMesh::CFace *pF2, bool bTestUV = true, bool bTestNormal = true )
{
sint32 i, j;
sint32 F1c[2] = { -1, -1 };
sint32 F2c[2] = { -1, -1 };
// Is there a vertices continuity
for( j = 0; j < 3; ++j )
for( i = 0; i < 3; ++i )
{
if( (pF1->Corner[j].Vertex == pF2->Corner[i].Vertex) &&
(pF1->Corner[(j+1)%3].Vertex == pF2->Corner[(i+1)%3].Vertex) )
{
F1c[0] = j; F1c[1] = (j+1)%3;
F2c[0] = i; F2c[1] = (i+1)%3;
}
if( (pF1->Corner[j].Vertex == pF2->Corner[(i+1)%3].Vertex) &&
(pF1->Corner[(j+1)%3].Vertex == pF2->Corner[i].Vertex) )
{
F1c[0] = (j+1)%3; F1c[1] = j;
F2c[0] = i; F2c[1] = (i+1)%3;
}
}
// No -> out
if( F1c[0] == -1 )
return false;
// Here we get the vertex continuity between F1c[0] and F2c[0], and, F1c[1] and F2c[1]
// Is there a normal continuity
if( bTestNormal )
for( i = 0; i < 2; ++i )
{
CVector n1 = pF1->Corner[F1c[i]].Normal;
CVector n2 = pF2->Corner[F2c[i]].Normal;
// is n1 equal to n2 ?
double epsilon = 1.0 - (n1*n2); // theorically n1*n2 equal to 1.0 but epsilon error
if( epsilon > 0.001 )
return false;
}
// Is there a mapping continuity
if( bTestUV )
for( i = 0; i < 2; ++i )
{
if((fabs( pF1->Corner[F1c[i]].Uvws[1].U - pF2->Corner[F2c[i]].Uvws[1].U) > 0.001) ||
(fabs( pF1->Corner[F1c[i]].Uvws[1].V - pF2->Corner[F2c[i]].Uvws[1].V) > 0.001) )
return false;
}
return true;
}
// -----------------------------------------------------------------------------------------------
void SortFaceBySMoothGroup( vector<sint32> &FaceGroup, vector<CMesh::CFace*>::iterator ItFaces, sint32 nNbFace )
{
sint32 j, k, nGroupNb = 0, nGroupOffset = 1;
bool bFaceAdded;
// Bubble sort face
FaceGroup.resize(nNbFace);
for( j = 0; j < nNbFace; ++j )
FaceGroup[j] = 1;
vector<CMesh::CFace*>::iterator CurGrpBeg = ItFaces;
vector<CMesh::CFace*>::iterator CurGrpEnd = ItFaces;
for( nGroupOffset = 1; nGroupOffset <= nNbFace; )
{
do
{
bFaceAdded = false;
vector<CMesh::CFace*>::iterator ItParseJ = CurGrpEnd;
++ItParseJ;
for( j = nGroupOffset; j < nNbFace; ++j )
{
// Is the face is connected to one of the current group
vector<CMesh::CFace*>::iterator ItParseK = CurGrpBeg;
for( k = 0; k < FaceGroup[nGroupNb]; ++k )
{
if( FaceContinuous( *ItParseK, *ItParseJ, false ) )
{
// Yes the face must be added at the end of the group
++CurGrpEnd;
CMesh::CFace *pFaceTemp = *CurGrpEnd;
*CurGrpEnd = *ItParseJ;
*ItParseJ = pFaceTemp;
nGroupOffset += 1;
FaceGroup[nGroupNb] += 1;
bFaceAdded = true;
break;
}
++ItParseK;
}
++ItParseJ;
}
} while( bFaceAdded ); // In this pass have we added faces ?
// No -> Next smooth group
++CurGrpEnd;
CurGrpBeg = CurGrpEnd;
++nGroupNb;
nGroupOffset += 1;
}
FaceGroup.resize(nGroupNb);
}
// -----------------------------------------------------------------------------------------------
void SortFaceByTextureSurface( int offset, int nNbFace, vector<CMesh::CFace*> &AllFaces )
{
int i, j;
for( i = 0; i < nNbFace-1; ++i )
for( j = i+1; j < nNbFace; ++j )
if( AllFaces[i]->MaterialId == AllFaces[j]->MaterialId )
{
// Texture surface of the i face = .5*|(u1-u0)*(v2-v0)-(v1-v0)*(u2-u0)|
// in fact this is lightmap mapping surface
double surfacei = 0.5*fabs(
(AllFaces[i]->Corner[1].Uvws[1].U - AllFaces[i]->Corner[0].Uvws[1].U)*
(AllFaces[i]->Corner[2].Uvws[1].V - AllFaces[i]->Corner[0].Uvws[1].V)-
(AllFaces[i]->Corner[1].Uvws[1].V - AllFaces[i]->Corner[0].Uvws[1].V)*
(AllFaces[i]->Corner[2].Uvws[1].U - AllFaces[i]->Corner[0].Uvws[1].U) );
double surfacej = 0.5*fabs(
(AllFaces[j]->Corner[1].Uvws[1].U - AllFaces[j]->Corner[0].Uvws[1].U)*
(AllFaces[j]->Corner[2].Uvws[1].V - AllFaces[j]->Corner[0].Uvws[1].V)-
(AllFaces[j]->Corner[1].Uvws[1].V - AllFaces[j]->Corner[0].Uvws[1].V)*
(AllFaces[j]->Corner[2].Uvws[1].U - AllFaces[j]->Corner[0].Uvws[1].U) );
if( surfacei < surfacej )
{
CMesh::CFace *pFaceTemp = AllFaces[i];
AllFaces[i] = AllFaces[j];
AllFaces[j] = pFaceTemp;
}
}
}
// -----------------------------------------------------------------------------------------------
bool isInTriangleOrEdge(double x, double y, double xt1, double yt1, double xt2, double yt2, double xt3, double yt3)
{
// Test vector T1X and T1T2
double sign1 = ((xt2-xt1)*(y-yt1) - (yt2-yt1)*(x-xt1));
// Test vector T2X and T2T3
double sign2 = ((xt3-xt2)*(y-yt2) - (yt3-yt2)*(x-xt2));
// Test vector T3X and T3T1
double sign3 = ((xt1-xt3)*(y-yt3) - (yt1-yt3)*(x-xt3));
if( (sign1 <= 0.0)&&(sign2 <= 0.0)&&(sign3 <= 0.0) )
return true;
if( (sign1 >= 0.0)&&(sign2 >= 0.0)&&(sign3 >= 0.0) )
return true;
return false;
}
// -----------------------------------------------------------------------------------------------
bool isInTriangle(double x, double y, double xt1, double yt1, double xt2, double yt2, double xt3, double yt3)
{
// Test vector T1X and T1T2
double sign1 = ((xt2-xt1)*(y-yt1) - (yt2-yt1)*(x-xt1));
// Test vector T2X and T2T3
double sign2 = ((xt3-xt2)*(y-yt2) - (yt3-yt2)*(x-xt2));
// Test vector T3X and T3T1
double sign3 = ((xt1-xt3)*(y-yt3) - (yt1-yt3)*(x-xt3));
if( (sign1 < 0.0)&&(sign2 < 0.0)&&(sign3 < 0.0) )
return true;
if( (sign1 > 0.0)&&(sign2 > 0.0)&&(sign3 > 0.0) )
return true;
return false;
}
// Segment line intersection P1P2 and P3P4
// -----------------------------------------------------------------------------------------------
bool segmentIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
double denominator = (y4-y3)*(x2-x1) - (x4-x3)*(y2-y1);
if( denominator == 0.0 )
return false; // The segment are colinear
double k = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3) ) / denominator;
if( (k<=0.0) || (k>=1.0) ) return false;
k = ( (x2-x1)*(y1-y3) - (y2-y1)*(x1-x3) ) / denominator;
if( (k<=0.0) || (k>=1.0) ) return false;
return true;
}
// -----------------------------------------------------------------------------------------------
bool 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;
}
// -----------------------------------------------------------------------------------------------
void CreatePiece( vector<uint8>& Piece, sint32& nSizeX, sint32& nSizeY, sint32 &nPosX, sint32 &nPosY,
float lumx1, float lumy1,
float lumx2, float lumy2,
float lumx3, float lumy3, uint8 nCol )
{
double minx, miny;
double maxx, maxy;
int j,k;
if( nCol == 0 )
nCol = 1;
minx = lumx1;
if( minx > lumx2 ) minx = lumx2;
if( minx > lumx3 ) minx = lumx3;
maxx = lumx1;
if( maxx < lumx2 ) maxx = lumx2;
if( maxx < lumx3 ) maxx = lumx3;
miny = lumy1;
if( miny > lumy2 ) miny = lumy2;
if( miny > lumy3 ) miny = lumy3;
maxy = lumy1;
if( maxy < lumy2 ) maxy = lumy2;
if( maxy < lumy3 ) maxy = lumy3;
// Put the piece in the new basis (nPosX,nPosY)
nPosX = ((sint32)floor(minx-0.5));
nPosY = ((sint32)floor(miny-0.5));
lumx1 -= nPosX; lumy1 -= nPosY;
lumx2 -= nPosX; lumy2 -= nPosY;
lumx3 -= nPosX; lumy3 -= nPosY;
nSizeX = 1 + ((sint32)floor(maxx+0.5)) - ((sint32)floor(minx-0.5));
nSizeY = 1 + ((sint32)floor(maxy+0.5)) - ((sint32)floor(miny-0.5));
Piece.resize( nSizeX*nSizeY );
for( j = 0; j < nSizeX*nSizeY; ++j )
Piece[j] = 0;
// The square interact with the triangle if an edge of the square is cut by an edge of the triangle
// Or the square is in the triangle
for( j = 0; j < nSizeY-1; ++j )
for( k = 0; k < nSizeX-1; ++k )
{
// Is the square (j,k) is interacting with the triangle
// This means : The square contains a point of the triangle (can be done for the 3 points)
// The triangle contains a point of the square
// If so then we have to turn on all the 4 pixels of the square
if( isInTriangleOrEdge(k+0.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+1.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+0.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+1.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) )
{
Piece[k + j *nSizeX] = nCol;
Piece[1+k + j *nSizeX] = nCol;
Piece[k + (1+j)*nSizeX] = nCol;
Piece[1+k + (1+j)*nSizeX] = nCol;
}
if( segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) )
{
Piece[k + j *nSizeX] = nCol;
Piece[1+k + j *nSizeX] = nCol;
Piece[k + (1+j)*nSizeX] = nCol;
Piece[1+k + (1+j)*nSizeX] = nCol;
}
}
// For all the points of the triangle update the square
Piece[((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5))*nSizeX] = nCol;
Piece[1+((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5))*nSizeX] = nCol;
Piece[((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*nSizeX] = nCol;
Piece[1+((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*nSizeX] = nCol;
Piece[((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5))*nSizeX] = nCol;
Piece[1+((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5))*nSizeX] = nCol;
Piece[((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*nSizeX] = nCol;
Piece[1+((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*nSizeX] = nCol;
Piece[((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5))*nSizeX] = nCol;
Piece[1+((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5))*nSizeX] = nCol;
Piece[((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*nSizeX] = nCol;
Piece[1+((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*nSizeX] = nCol;
}
// -----------------------------------------------------------------------------------------------
void ResizeBitmap( vector<uint8> &vBitmap, sint32 &nSizeX, sint32 &nSizeY, sint32 nNewSizeX, sint32 nNewSizeY )
{
vector<uint8> vImgTemp;
int i, j;
vImgTemp.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
vImgTemp[i] = 0;
for( j = 0; j < min(nSizeY,nNewSizeY); ++j )
for( i = 0; i < min(nSizeX,nNewSizeX); ++i )
{
vImgTemp[i+j*nNewSizeX] = vBitmap[i+j*nSizeX];
}
vBitmap.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
vBitmap[i] = vImgTemp[i];
nSizeX = nNewSizeX;
nSizeY = nNewSizeY;
}
// -----------------------------------------------------------------------------------------------
// Same as ResizeBitmap but for 32 bits image
void ResizeBitmap32( CBitmap *pImage, sint32 nNewSizeX, sint32 nNewSizeY )
{
vector<uint8> vImgTemp;
int i, j;
vImgTemp.resize( 4*nNewSizeX*nNewSizeY );
for( i = 0; i < 4*nNewSizeX*nNewSizeY; ++i )
vImgTemp[i] = 0;
CObjectVector<uint8> &vBitmap = pImage->getPixels();
sint32 nCurSizeX = pImage->getWidth();
sint32 nCurSizeY = pImage->getHeight();
for( j = 0; j < min(nCurSizeY,nNewSizeY); ++j )
for( i = 0; i < min(nCurSizeX,nNewSizeX); ++i )
{
vImgTemp[4*(i+j*nNewSizeX)+0] = vBitmap[4*(i+j*pImage->getWidth())+0];
vImgTemp[4*(i+j*nNewSizeX)+1] = vBitmap[4*(i+j*pImage->getWidth())+1];
vImgTemp[4*(i+j*nNewSizeX)+2] = vBitmap[4*(i+j*pImage->getWidth())+2];
vImgTemp[4*(i+j*nNewSizeX)+3] = vBitmap[4*(i+j*pImage->getWidth())+3];
}
pImage->resize(nNewSizeX,nNewSizeY);
vBitmap = pImage->getPixels();
for( i = 0; i < 4*nNewSizeX*nNewSizeY; ++i )
vBitmap[i] = vImgTemp[i];
}
// -----------------------------------------------------------------------------------------------
bool PutPieceInLightMap( vector<uint8>& Piece, sint32 nPieceSizeX, sint32 nPieceSizeY,
vector<uint8>& LightMap, sint32 nLightMapSizeX, sint32 nLightMapSizeY,
sint32 &nNewPosX, sint32 &nNewPosY )
{
sint32 i, j, a, b;
bool bGoodPosition;
if( nPieceSizeX > nLightMapSizeX ) return false;
if( nPieceSizeY > nLightMapSizeY ) return false;
// For all position test if the piece can be put in
for( j = 0; j < (nLightMapSizeY-nPieceSizeY); ++j )
for( i = 0; i < (nLightMapSizeX-nPieceSizeX); ++i )
{
bGoodPosition = true;
for( b = 0; b < nPieceSizeY; ++b )
{
for( a = 0; a < nPieceSizeX; ++a )
{
if( Piece[a+b*nPieceSizeX] != 0 )
if( LightMap[(i+a)+(j+b)*nLightMapSizeX] != 0 )
{
bGoodPosition = false;
break;
}
}
if( bGoodPosition == false )
break;
}
if( bGoodPosition )
{
// Write the piece in the lightmap !!!
for( b = 0; b < nPieceSizeY; ++b )
{
for( a = 0; a < nPieceSizeX; ++a )
{
if( Piece[a+b*nPieceSizeX] != 0 )
LightMap[(i+a)+(j+b)*nLightMapSizeX] = Piece[a+b*nPieceSizeX];
}
}
nNewPosX = i;
nNewPosY = j;
return true;
}
}
return false;
}
// -----------------------------------------------------------------------------------------------
void MapFace( CMesh::CFace *pFace, vector<CVector> &Vertices, float rRatio )
{
CVector V01 = Vertices[pFace->Corner[1].Vertex] - Vertices[pFace->Corner[0].Vertex];
CVector V02 = Vertices[pFace->Corner[2].Vertex] - Vertices[pFace->Corner[0].Vertex];
CVector n = V01 ^ V02;
n.normalize();
// Quantize the normal
// Table of unitary vector with relevant direction to map The I vector represent the plane normal
// and the J,K vector the U,V vector
CMatrix QuantizationTbl[3];
QuantizationTbl[0].identity();
QuantizationTbl[1].identity(); QuantizationTbl[1].rotateZ((float)(Pi/2.0));
QuantizationTbl[2].identity(); QuantizationTbl[2].rotateY((float)(Pi/2.0));
float fMax = 0.0f;
int pos = 0;
for( int i = 0; i < 3; ++i )
{
if( fMax < fabsf(QuantizationTbl[i].getI()*n) )
{
fMax = fabsf(QuantizationTbl[i].getI()*n);
pos = i;
}
}
// Map with the i_th vector from the quantization table
// Projection of the 3 vertices of the triangle on the plane
// defined by the quantized vector (as the plane normal) and the origin (as a point in the plane)
// This is equivalent to a base changement with annulation of the I vector
CMatrix invMat = QuantizationTbl[pos].inverted();
CVector newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[0].Vertex]);
pFace->Corner[0].Uvws[1].U = newPtinUVBasis.y / rRatio;
pFace->Corner[0].Uvws[1].V = newPtinUVBasis.z / rRatio;
newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[1].Vertex]);
pFace->Corner[1].Uvws[1].U = newPtinUVBasis.y / rRatio;
pFace->Corner[1].Uvws[1].V = newPtinUVBasis.z / rRatio;
newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[2].Vertex]);
pFace->Corner[2].Uvws[1].U = newPtinUVBasis.y / rRatio;
pFace->Corner[2].Uvws[1].V = newPtinUVBasis.z / rRatio;
}
// -----------------------------------------------------------------------------------------------
CMatrix getObjectToWorldMatrix( CMesh::CMeshBuild *pMB )
{
CMatrix m1, m2, m3, m4, m5;
m1.identity();
m1.setPos( pMB->DefaultPivot );
m1.invert();
m2.identity();
m2.scale( pMB->DefaultScale );
m3.identity();
m3.setRot( pMB->DefaultRotQuat );
m4.identity();
m4.setPos( pMB->DefaultPivot );
m5.identity();
m5.setPos( pMB->DefaultPos );
m1 = m5*m4*m3*m2*m1;
return m1;
}
// -----------------------------------------------------------------------------------------------
float getUVDist( CUV& UV1, CUV& UV2 )
{
return sqrtf( (UV2.U - UV1.U)*(UV2.U - UV1.U) + (UV2.V - UV1.V)*(UV2.V - UV1.V) );
}
// -----------------------------------------------------------------------------------------------
void getLightBuildList(std::vector<SLightBuild>& vectLight, TimeValue tvTime, Interface& ip, INode*node=NULL )
{
if( node == NULL )
node = ip.GetRootNode();
// Get a pointer on the object's node
Object *obj = node->EvalWorldState(tvTime).obj;
// Check if there is an object
if (obj)
{
// Get a GenLight from the node
if (obj->SuperClassID()==LIGHT_CLASS_ID)
{
GenLight *maxLight = (GenLight *) obj;
bool deleteIt=false;
if (obj != maxLight)
deleteIt = true;
SLightBuild nelLight;
// Is the light is animatable ? (TEMP MAT)
Modifier *pModifier = CExportNel::getModifier( node, Class_ID(NEL_LIGHT_CLASS_ID_A, NEL_LIGHT_CLASS_ID_B) );
if( pModifier != NULL )
{
int bDynamic;
string sGroup;
// Get the value of the parameters
CExportNel::getValueByNameUsingParamBlock2( *pModifier, "bDynamic", (ParamType2)TYPE_BOOL, &bDynamic, 0);
CExportNel::getValueByNameUsingParamBlock2( *pModifier, "sGroup", (ParamType2)TYPE_STRING, &sGroup, 0);
if( bDynamic )
{
nelLight.bAnimate = false;
nelLight.GroupName = sGroup;
}
}
else
{
nelLight.bAnimate = false;
nelLight.GroupName = "GlobalLight";
}
// Eval the light state fot this tvTime
Interval valid=NEVER;
LightState ls;
if (maxLight->EvalLightState(tvTime, valid, &ls)==REF_SUCCEED)
{
// Set the light mode
switch (maxLight->Type())
{
case OMNI_LIGHT:
nelLight.Type = SLightBuild::EType::LightPoint;
break;
case TSPOT_LIGHT:
case FSPOT_LIGHT:
nelLight.Type = SLightBuild::EType::LightSpot;
break;
case DIR_LIGHT:
case TDIR_LIGHT:
nelLight.Type = SLightBuild::EType::LightDir;
break;
default:
// Not initialized
break;
}
// *** Set the light color
// Get the color
CRGBA nelColor;
Point3 maxColor = maxLight->GetRGBColor(tvTime);
// Mul by multiply
CRGBAF nelFColor;
nelFColor.R = maxColor.x;
nelFColor.G = maxColor.y;
nelFColor.B = maxColor.z;
nelFColor.A = 1.f;
nelFColor *= maxLight->GetIntensity(tvTime);
nelColor = nelFColor;
// Affect the ambiant color ?
nelLight.Ambient = nelColor;
nelLight.Diffuse = CRGBA (0,0,0);
nelLight.Specular = CRGBA (0,0,0);
/*
if (maxLight->GetAmbientOnly())
{
nelLight.Ambient = nelColor;
}
else
*/
{
// Affect the diffuse color ?
if( maxLight->GetAffectDiffuse() )
nelLight.Diffuse = nelColor;
// Affect the specular color ?
if (maxLight->GetAffectSpecular())
nelLight.Specular = nelColor;
}
// Set the light position
Point3 pos = node->GetNodeTM(tvTime).GetTrans ();
CVector position;
position.x=pos.x;
position.y=pos.y;
position.z=pos.z;
// Set the position
nelLight.Position = position;
// Set the light direction
CVector direction;
INode* target = node->GetTarget ();
if (target)
{
// Get the position of the target
Point3 posTarget=target->GetNodeTM (tvTime).GetTrans ();
CVector positionTarget;
positionTarget.x=posTarget.x;
positionTarget.y=posTarget.y;
positionTarget.z=posTarget.z;
// Direction
direction=positionTarget-position;
direction.normalize ();
}
else // No target
{
// Get orientation of the source as direction
CMatrix nelMatrix;
CExportNel::convertMatrix (nelMatrix, node->GetNodeTM(tvTime));
// Direction is -Z
direction=-nelMatrix.getK();
direction.normalize ();
}
// Set the direction
nelLight.Direction = direction;
/*
// Set spot light information
nelLight.setCutoff ((float)(NLMISC::Pi*maxLight.GetFallsize(tvTime)/180.f/2.f));
// Compute the exponent value
float angle=(float)(NLMISC::Pi*maxLight.GetHotspot(tvTime)/(2.0*180.0));
nelLight.setupSpotExponent (angle);
// *** Set attenuation
if (maxLight.GetUseAtten())
nelLight.setupAttenuation (maxLight.GetAtten (tvTime, ATTEN_START), maxLight.GetAtten (tvTime, ATTEN_END));
else
nelLight.setNoAttenuation ();
*/
nelLight.rHotspot = (float)(Pi * maxLight->GetHotspot(tvTime) /(2.0*180.0));
nelLight.rFallof = (float)(Pi * maxLight->GetFallsize(tvTime)/(2.0*180.0));
if (maxLight->GetUseAtten())
{
nelLight.rRadiusMin = maxLight->GetAtten (tvTime, ATTEN_START);
nelLight.rRadiusMax = maxLight->GetAtten (tvTime, ATTEN_END);
}
else
{ // Limit
nelLight.rRadiusMin = 10.0;
nelLight.rRadiusMax = 10.0;
}
nelLight.bCastShadow = ( maxLight->GetShadow() != 0 );
nelLight.rMult = maxLight->GetShadMult (tvTime);
// Add the light in the list
vectLight.push_back (nelLight);
}
if( deleteIt )
delete maxLight;
}
}
// Recurse sub node
for (int i=0; i<node->NumberOfChildren(); i++)
getLightBuildList(vectLight, tvTime, ip, node->GetChildNode(i));
}
// -----------------------------------------------------------------------------------------------
void getLightBuilds( vector<SLightBuild> &lights, TimeValue tvTime, Interface& ip )
{
SLightBuild amb;
amb.Type = SLightBuild::EType::LightAmbient;
amb.GroupName = "GlobalLight";
amb.bAnimate = false;
amb.Ambient.R = (uint8)(ip.GetAmbient( tvTime, FOREVER ).x*255);
amb.Ambient.G = (uint8)(ip.GetAmbient( tvTime, FOREVER ).y*255);
amb.Ambient.B = (uint8)(ip.GetAmbient( tvTime, FOREVER ).z*255);
amb.Ambient.A = 255;
amb.Specular = amb.Diffuse = CRGBA(0,0,0,0);
lights.push_back( amb );
getLightBuildList( lights, tvTime, ip );
}
// -----------------------------------------------------------------------------------------------
void MoveFaceUV1( vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace, double rOffsU, double rOffsV )
{
sint32 i,j ;
for( i = 0; i < nNbFace; ++i )
{
CMesh::CFace *pF = (*ItFace);
for( j = 0; j < 3; ++j )
{
pF->Corner[j].Uvws[1].U += (float)rOffsU;
pF->Corner[j].Uvws[1].V += (float)rOffsV;
}
++ItFace;
}
}
// -----------------------------------------------------------------------------------------------
double calculateTriangleSurface( CVector &p1, CVector &p2, CVector &p3 )
{
CVector n = ((p2-p1)^(p3-p1));
return 0.5 * n.norm(); // Half of the norm
}
// -----------------------------------------------------------------------------------------------
void MultiplyFaceUV1( vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace, double rFactor )
{
sint32 i,j ;
for( i = 0; i < nNbFace; ++i )
{
CMesh::CFace *pF = (*ItFace);
for( j = 0; j < 3; ++j )
{
pF->Corner[j].Uvws[1].U *= (float)rFactor;
pF->Corner[j].Uvws[1].V *= (float)rFactor;
}
++ItFace;
}
}
// -----------------------------------------------------------------------------------------------
bool PutFaceUV1InLumelCoord( double rRatioLightMap, vector<CVector> &Vertices,
vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace )
{
sint32 i, j;
double SpaceSurf = 0.0, TextureSurf = 0.0;
vector<CMesh::CFace*>::iterator ItParseI = ItFace;
for( i = 0; i < nNbFace; ++i )
{
CVector p1, p2, p3;
CMesh::CFace* pF = (*ItParseI);
p1 = Vertices[pF->Corner[0].Vertex];
p2 = Vertices[pF->Corner[1].Vertex];
p3 = Vertices[pF->Corner[2].Vertex];
SpaceSurf += calculateTriangleSurface( p1, p2, p3 );
p1.x = pF->Corner[0].Uvws[1].U; p1.y = pF->Corner[0].Uvws[1].V; p1.z = 0.0f;
p2.x = pF->Corner[1].Uvws[1].U; p2.y = pF->Corner[1].Uvws[1].V; p2.z = 0.0f;
p3.x = pF->Corner[2].Uvws[1].U; p3.y = pF->Corner[2].Uvws[1].V; p3.z = 0.0f;
TextureSurf += calculateTriangleSurface( p1, p2, p3 );
// Next face
++ItParseI;
}
if( TextureSurf < 0.0001 )
return false;
double LMTextRatio = sqrt(SpaceSurf / TextureSurf) * (1.0/rRatioLightMap);
ItParseI = ItFace;
for( i = 0; i < nNbFace; ++i )
{
CMesh::CFace* pF = (*ItParseI);
for( j = 0; j < 3; ++j ) // Express the UVs in lumel for each corner
{
pF->Corner[j].Uvws[1].U *= (float)LMTextRatio;
pF->Corner[j].Uvws[1].V *= (float)LMTextRatio;
}
++ItParseI;
}
return true;
}
// -----------------------------------------------------------------------------------------------
void PutFaceUV1InTextureCoord( sint32 TextureSizeX, sint32 TextureSizeY,
vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace )
{
sint32 i,j;
for( i = 0; i < nNbFace; ++i )
{
for( j = 0; j < 3; ++j )
{
CMesh::CFace *pF = *ItFace;
pF->Corner[j].Uvws[1].U /= (float)TextureSizeX;
pF->Corner[j].Uvws[1].V /= (float)TextureSizeY;
}
// Next face
++ItFace;
}
}
// -----------------------------------------------------------------------------------------------
bool IsFaceCoverFace( CMesh::CFace *pF1, CMesh::CFace *pF2 )
{
sint32 i, j;
for( j = 0; j < 3; ++j )
for( i = 0; i < 3; ++i )
if( segmentIntersection(pF1->Corner[i].Uvws[1].U, pF1->Corner[i].Uvws[1].V,
pF1->Corner[(i+1)%3].Uvws[1].U, pF1->Corner[(i+1)%3].Uvws[1].V,
pF2->Corner[j].Uvws[1].U, pF2->Corner[j].Uvws[1].V,
pF2->Corner[(j+1)%3].Uvws[1].U, pF2->Corner[(j+1)%3].Uvws[1].V ) )
return true;
for( i = 0; i < 3; ++i )
if( isInTriangle( pF1->Corner[i].Uvws[1].U, pF1->Corner[i].Uvws[1].V,
pF2->Corner[0].Uvws[1].U, pF2->Corner[0].Uvws[1].V,
pF2->Corner[1].Uvws[1].U, pF2->Corner[1].Uvws[1].V,
pF2->Corner[2].Uvws[1].U, pF2->Corner[2].Uvws[1].V ) )
return true;
for( i = 0; i < 3; ++i )
if( isInTriangle( pF2->Corner[i].Uvws[1].U, pF2->Corner[i].Uvws[1].V,
pF1->Corner[0].Uvws[1].U, pF1->Corner[0].Uvws[1].V,
pF1->Corner[1].Uvws[1].U, pF1->Corner[1].Uvws[1].V,
pF1->Corner[2].Uvws[1].U, pF1->Corner[2].Uvws[1].V ) )
return true;
return false;
}
// -----------------------------------------------------------------------------------------------
void SortFaceByPlane( vector<sint32> &FaceGroup, vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace )
{
sint32 j, k, nGroupNb = 0;
FaceGroup.resize( nNbFace );
for( j = 0; j < nNbFace; ++j )
FaceGroup[j] = 1;
vector<CMesh::CFace*>::iterator CurGrpBeg = ItFace;
vector<CMesh::CFace*>::iterator CurGrpEnd = ItFace;
sint32 nGroupOffset = 1;
list<CMesh::CFace*> lifo;
lifo.clear();
for( nGroupOffset = 1; nGroupOffset <= nNbFace; )
{
lifo.push_front( *CurGrpBeg );
// Do a complete plane : Graph traversal in width
while( ! lifo.empty() )
{
CMesh::CFace *pFace = lifo.back();
lifo.pop_back();
vector<CMesh::CFace*>::iterator ItParseJ = CurGrpEnd;
++ItParseJ;
for( j = nGroupOffset; j < nNbFace; ++j )
{
if( FaceContinuous( pFace, *ItParseJ ) )
{
// Is this face cover other face present in the current group ?
vector<CMesh::CFace*>::iterator ItParseK = CurGrpBeg;
bool bFaceCovering = false;
for( k = 0; k < FaceGroup[nGroupNb]; ++k )
{
if( IsFaceCoverFace( *ItParseK, *ItParseJ ) )
{
bFaceCovering = true;
break;
}
++ItParseK;
}
// The face do not cover other face -> add it to current group
if( !bFaceCovering )
{
lifo.push_front( *ItParseJ );
++CurGrpEnd;
CMesh::CFace *pFaceTemp = *CurGrpEnd;
*CurGrpEnd = *ItParseJ;
*ItParseJ = pFaceTemp;
nGroupOffset += 1;
FaceGroup[nGroupNb] += 1;
}
}
++ItParseJ;
}
}
++CurGrpEnd;
CurGrpBeg = CurGrpEnd;
++nGroupNb;
nGroupOffset += 1;
}
FaceGroup.resize( nGroupNb );
}
// -----------------------------------------------------------------------------------------------
void SortPlanesBySurface( vector<SLMPlane*> &planes )
{
uint32 i, j;
for( i = 0; i < planes.size()-1; ++i )
for( j = i+1; j < planes.size(); ++j )
{
if( (planes[i]->w *planes[i]->h) < (planes[j]->w *planes[j]->h) )
{
SLMPlane *tmp = planes[i];
planes[i] = planes[j];
planes[j] = tmp;
}
}
}
/* // To keep
void SortPlanesBySurface( vector<sint32> &PlaneGroup, vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace )
{
sint32 i, j, k;
double rMinU = 1000000.0, rMaxU = -1000000.0, rMinV = 1000000.0, rMaxV = -1000000.0;
CMesh::CFace *pF;
vector< pair < sint32, sint32 > > sizes;
sizes.resize( PlaneGroup.size() );
// Get the size of surface for each plane
vector<CMesh::CFace*>::iterator ItParseI = ItFace;
for( i = 0; i < sizes.size(); ++i )
{
rMinU = 1000000.0; rMaxU = -1000000.0;
rMinV = 1000000.0; rMaxV = -1000000.0;
for( j = 0; j < PlaneGroup[i]; ++j )
{
pF = *ItParseI;
for( k = 0; k < 3; ++k )
{
if( rMinU > pF->Corner[k].Uvws[1].U ) rMinU = pF->Corner[k].Uvws[1].U;
if( rMaxU < pF->Corner[k].Uvws[1].U ) rMaxU = pF->Corner[k].Uvws[1].U;
if( rMinV > pF->Corner[k].Uvws[1].V ) rMinV = pF->Corner[k].Uvws[1].V;
if( rMaxV < pF->Corner[k].Uvws[1].V ) rMaxV = pF->Corner[k].Uvws[1].V;
}
++ItParseI;
}
sizes[i].first = i;
sizes[i].second = (rMaxU - rMinU) * (rMaxV - rMinV);
}
// Sort surfaces to put the biggest first
for( i = 0; i < sizes.size()-1; ++i )
for( j = i+1; j < sizes.size(); ++j )
{
if( sizes[i].second < sizes[j].second )
{
pair< sint32, sint32 > tmp = sizes[i];
sizes[i] = sizes[j];
sizes[j] = tmp;
}
}
vector<CMesh::CFace*> TempGrp;
vector<CMesh::CFace*>::iterator ItParseOut;
TempGrp.resize( nNbFace );
ItParseOut = TempGrp.begin();
for( i = 0; i < sizes.size(); ++i )
{
// Treating group
j = sizes[i].first;
ItParseI = ItFace;
// Positionnement of the pointer to the first face of the j th group
for( k = 0; k < j; ++k )
ItParseI += PlaneGroup[k];
// Copy the group j at the end of TempGrp
for( k = 0; k < PlaneGroup[j]; ++k )
{
*ItParseOut = *ItParseI;
++ItParseOut;
++ItParseI;
}
}
// So now we just have to copy back the temporary group
ItParseOut = TempGrp.begin();
ItParseI = ItFace;
for( i = 0; i < nNbFace; ++i )
{
*ItParseI = *ItParseOut;
++ItParseOut;
++ItParseI;
}
// And the same with the group delimiter
for( i = 0; i < sizes.size(); ++i )
{
j = sizes[i].first;
sizes[i].first = PlaneGroup[j];
}
for( i = 0; i < sizes.size(); ++i )
PlaneGroup[i] = sizes[i].first;
}
*/
// -----------------------------------------------------------------------------------------------
void PutLMPlaneInLMPlane( SLMPlane &Dst, SLMPlane &Src, bool bMaskOnly = false )
{
sint32 a, b;
if( ( (Src.w + Src.x) > Dst.w ) || ( (Src.h + Src.y) > Dst.h ) )
{
a = 0; b = 0;
}
for( b = 0; b < Src.h; ++b )
for( a = 0; a < Src.w; ++a )
if( Src.msk[a+b*Src.w] != 0 )
{
Dst.msk[(Src.x+a)+(Src.y+b)*Dst.w] = Src.msk[a+b*Src.w];
if( bMaskOnly == false )
Dst.col[(Src.x+a)+(Src.y+b)*Dst.w] = Src.col[a+b*Src.w];
}
}
// -----------------------------------------------------------------------------------------------
bool TestLMPLaneInLMPlane( SLMPlane &Dst, SLMPlane &Src )
{
sint32 a, b;
for( b = 0; b < Src.h; ++b )
for( a = 0; a < Src.w; ++a )
if( Src.msk[a+b*Src.w] != 0 )
if( Dst.msk[(Src.x+a)+(Src.y+b)*Dst.w] != 0 )
return false;
return true;
}
// -----------------------------------------------------------------------------------------------
bool TryAllPosForLMPlaneInLMPlane( SLMPlane &Dst, SLMPlane &Src )
{
sint32 i, j;
if( Src.w > Dst.w ) return false;
if( Src.h > Dst.h ) return false;
// For all position test if the Src plane can be put in
for( j = 0; j < (Dst.h-Src.h); ++j )
for( i = 0; i < (Dst.w-Src.w); ++i )
{
Src.x = i; Src.y = j;
if( TestLMPLaneInLMPlane( Dst, Src ) )
return true;
}
return false;
}
// -----------------------------------------------------------------------------------------------
void CopyPlaneColToBitmap32( CBitmap* pImage, SLMPlane &Plane, sint32 nLayerNb )
{
if( ( pImage->getWidth() != Plane.w ) ||
( pImage->getHeight() != Plane.h ) )
ResizeBitmap32( pImage, Plane.w, Plane.h );
CObjectVector<uint8> &vBitmap = pImage->getPixels();
for( sint32 i = 0; i < Plane.w*Plane.h; ++i )
{
vBitmap[4*i+0] = (uint8)(127.0*Plane.col[i].p[nLayerNb].R);
vBitmap[4*i+1] = (uint8)(127.0*Plane.col[i].p[nLayerNb].G);
vBitmap[4*i+2] = (uint8)(127.0*Plane.col[i].p[nLayerNb].B);
vBitmap[4*i+3] = (uint8)(255.0*Plane.col[i].p[nLayerNb].A);
}
/* // To see contours
for( sint32 i = 0; i < Plane.w*Plane.h; ++i )
if( ( Plane.msk[i] == 0 ) || ( Plane.msk[i] == 1 ) || ( Plane.msk[i] == 3 ) )
{
vBitmap[i*4+0] = 0;
vBitmap[i*4+1] = 255;
vBitmap[i*4+2] = 0;
vBitmap[i*4+3] = 255;
}
else
{
vBitmap[i*4+0] = Plane.col[i*4+0];
vBitmap[i*4+1] = Plane.col[i*4+1];
vBitmap[i*4+2] = Plane.col[i*4+2];
vBitmap[i*4+3] = Plane.col[i*4+3];
}
*/
}
// -----------------------------------------------------------------------------------------------
// Do not stretch the image inside the plane
void ResizeLMPlane( SLMPlane &Dst, sint32 nNewSizeX, sint32 nNewSizeY )
{
vector<uint8> vImgTemp;
vector<SLMPixel> vImgTemp2;
int i, j;
vImgTemp.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
vImgTemp[i] = 0;
for( j = 0; j < min(Dst.h,nNewSizeY); ++j )
for( i = 0; i < min(Dst.w,nNewSizeX); ++i )
{
vImgTemp[i+j*nNewSizeX] = Dst.msk[i+j*Dst.w];
}
Dst.msk.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
Dst.msk[i] = vImgTemp[i];
// The same as the mask but for the bitmap
vImgTemp2.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
for( j = 0; j < 8; ++j )
{ vImgTemp2[i].p[j].R = vImgTemp2[i].p[j].G = vImgTemp2[i].p[j].B = vImgTemp2[i].p[j].A = 0.0f; }
for( j = 0; j < min(Dst.h,nNewSizeY); ++j )
for( i = 0; i < min(Dst.w,nNewSizeX); ++i )
vImgTemp2[i+j*nNewSizeX] = Dst.col[i+j*Dst.w];
Dst.col.resize(nNewSizeX*nNewSizeY);
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
Dst.col[i] = vImgTemp2[i];
Dst.w = nNewSizeX;
Dst.h = nNewSizeY;
}
// -----------------------------------------------------------------------------------------------
// Stretch a plane by a given factor 4.0 -> multiply its size by 4 and 0.5 -> halves its size
void stretchLMPlane( SLMPlane *pPlane, double osFactor )
{
sint32 nNewSizeX = (sint32)(pPlane->w * osFactor);
sint32 nNewSizeY = (sint32)(pPlane->h * osFactor);
vector<uint8> vImgTemp;
vector<SLMPixel> vImgTemp2;
int i, j, k;
// Reduce the color
vImgTemp2.resize( nNewSizeX * nNewSizeY );
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
for( j = 0; j < 8; ++j )
{ vImgTemp2[i].p[j].R = vImgTemp2[i].p[j].G = vImgTemp2[i].p[j].B = vImgTemp2[i].p[j].A = 0.0f; }
vImgTemp.resize( nNewSizeX * nNewSizeY );
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
vImgTemp[i] = 0;
double dx, dy, x, y;
if( osFactor > 1.0 ) // Up
{
dx = 1.0/osFactor;
dy = 1.0/osFactor;
y = 0.0;
for( j = 0; j < nNewSizeY; ++j )
{
x = 0.0;
for( i = 0; i < nNewSizeX; ++i )
{
if( pPlane->msk[((sint32)x)+((sint32)y)*pPlane->w] != 0 )
{
vImgTemp[i+j*nNewSizeX] = 1;
}
for( k = 0; k < 8; ++k )
{
vImgTemp2[i+j*nNewSizeX].p[k].R += pPlane->col[((sint32)x)+((sint32)y)*pPlane->w].p[k].R;
vImgTemp2[i+j*nNewSizeX].p[k].G += pPlane->col[((sint32)x)+((sint32)y)*pPlane->w].p[k].G;
vImgTemp2[i+j*nNewSizeX].p[k].B += pPlane->col[((sint32)x)+((sint32)y)*pPlane->w].p[k].B;
vImgTemp2[i+j*nNewSizeX].p[k].A += 1.0f;
}
x += dx;
}
y += dy;
}
}
else // Down
{
dx = osFactor;
dy = osFactor;
y = 0.0;
for( j = 0; j < pPlane->h; ++j )
{
x = 0.0;
for( i = 0; i < pPlane->w; ++i )
{
if( pPlane->msk[i+j*pPlane->w] != 0 )
{
vImgTemp[((sint32)x)+((sint32)y)*nNewSizeX] = 1;
}
for( k = 0; k < 8; ++k )
{
vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX].p[k].R += pPlane->col[i+j*pPlane->w].p[k].R;
vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX].p[k].G += pPlane->col[i+j*pPlane->w].p[k].G;
vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX].p[k].B += pPlane->col[i+j*pPlane->w].p[k].B;
vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX].p[k].A += 1.0f;
}
x += dx;
}
y += dy;
}
}
for( j = 0; j < nNewSizeY; ++j )
for( i = 0; i < nNewSizeX; ++i )
for( k = 0; k < 8; ++k )
if( vImgTemp2[i+j*nNewSizeX].p[k].A > 1.0f )
{
vImgTemp2[i+j*nNewSizeX].p[k].R /= vImgTemp2[i+j*nNewSizeX].p[k].A;
vImgTemp2[i+j*nNewSizeX].p[k].G /= vImgTemp2[i+j*nNewSizeX].p[k].A;
vImgTemp2[i+j*nNewSizeX].p[k].B /= vImgTemp2[i+j*nNewSizeX].p[k].A;
vImgTemp2[i+j*nNewSizeX].p[k].A = 1.0f;
}
pPlane->col.resize( nNewSizeX * nNewSizeY );
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
pPlane->col[i] = vImgTemp2[i];
pPlane->msk.resize( nNewSizeX * nNewSizeY );
for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
pPlane->msk[i] = vImgTemp[i];
pPlane->w = nNewSizeX;
pPlane->h = nNewSizeY;
pPlane->x = (sint32)(pPlane->x * osFactor);
pPlane->y = (sint32)(pPlane->y * osFactor);
}
// -----------------------------------------------------------------------------------------------
void CreateLMPlaneFromFace( SLMPlane &Out, CMesh::CFace *pF )
{
double lumx1 = pF->Corner[0].Uvws[1].U, lumy1 = pF->Corner[0].Uvws[1].V,
lumx2 = pF->Corner[1].Uvws[1].U, lumy2 = pF->Corner[1].Uvws[1].V,
lumx3 = pF->Corner[2].Uvws[1].U, lumy3 = pF->Corner[2].Uvws[1].V;
double minx, miny;
double maxx, maxy;
int j,k;
minx = lumx1;
if( minx > lumx2 ) minx = lumx2;
if( minx > lumx3 ) minx = lumx3;
maxx = lumx1;
if( maxx < lumx2 ) maxx = lumx2;
if( maxx < lumx3 ) maxx = lumx3;
miny = lumy1;
if( miny > lumy2 ) miny = lumy2;
if( miny > lumy3 ) miny = lumy3;
maxy = lumy1;
if( maxy < lumy2 ) maxy = lumy2;
if( maxy < lumy3 ) maxy = lumy3;
// Put the piece in the new basis (nPosX,nPosY)
Out.x = ((sint32)floor(minx-0.5));
Out.y = ((sint32)floor(miny-0.5));
lumx1 -= Out.x; lumy1 -= Out.y;
lumx2 -= Out.x; lumy2 -= Out.y;
lumx3 -= Out.x; lumy3 -= Out.y;
ResizeLMPlane( Out, 1 + ((sint32)floor(maxx+0.5)) - ((sint32)floor(minx-0.5)),
1 + ((sint32)floor(maxy+0.5)) - ((sint32)floor(miny-0.5)) );
for( j = 0; j < Out.w*Out.h; ++j )
{
Out.msk[j] = 0;
}
// The square interact with the triangle if an edge of the square is cut by an edge of the triangle
// Or the square is in the triangle
for( j = 0; j < Out.h-1; ++j )
for( k = 0; k < Out.w-1; ++k )
{
// Is the square (j,k) is interacting with the triangle
// This means : The square contains a point of the triangle (can be done for the 3 points)
// The triangle contains a point of the square
// If so then we have to turn on all the 4 pixels of the square
if( isInTriangleOrEdge(k+0.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+1.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+0.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
isInTriangleOrEdge(k+1.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) )
{
Out.msk[k + j *Out.w] = 1;
Out.msk[1+k + j *Out.w] = 1;
Out.msk[k + (1+j)*Out.w] = 1;
Out.msk[1+k + (1+j)*Out.w] = 1;
}
if( segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) )
{
Out.msk[k + j *Out.w] = 1;
Out.msk[1+k + j *Out.w] = 1;
Out.msk[k + (1+j)*Out.w] = 1;
Out.msk[1+k + (1+j)*Out.w] = 1;
}
}
// For all the points of the triangle update the square
// TODO : Test if we need it !
Out.msk[((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5)) *Out.w] = 1;
Out.msk[1+((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5)) *Out.w] = 1;
Out.msk[((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*Out.w] = 1;
Out.msk[1+((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*Out.w] = 1;
Out.msk[((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5)) *Out.w] = 1;
Out.msk[1+((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5)) *Out.w] = 1;
Out.msk[((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*Out.w] = 1;
Out.msk[1+((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*Out.w] = 1;
Out.msk[((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5)) *Out.w] = 1;
Out.msk[1+((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5)) *Out.w] = 1;
Out.msk[((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*Out.w] = 1;
Out.msk[1+((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*Out.w] = 1;
}
// -----------------------------------------------------------------------------------------------
// Warning : modify the Faces Uvws[1]
void CreateLMPlaneFromFaceGroup( SLMPlane &Plane, vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFace )
{
sint32 i, j;
double rMinU = 1000000.0, rMaxU = -1000000.0, rMinV = 1000000.0, rMaxV = -1000000.0;
vector<CMesh::CFace*>::iterator ItParseI = ItFace;
CMesh::CFace *pF;
Plane.faces.resize( nNbFace );
for( i = 0; i < nNbFace; ++i )
{
pF = *ItParseI;
for( j = 0; j < 3; ++j )
{
if( rMinU > pF->Corner[j].Uvws[1].U ) rMinU = pF->Corner[j].Uvws[1].U;
if( rMaxU < pF->Corner[j].Uvws[1].U ) rMaxU = pF->Corner[j].Uvws[1].U;
if( rMinV > pF->Corner[j].Uvws[1].V ) rMinV = pF->Corner[j].Uvws[1].V;
if( rMaxV < pF->Corner[j].Uvws[1].V ) rMaxV = pF->Corner[j].Uvws[1].V;
}
Plane.faces[i] = pF;
++ItParseI;
}
sint32 w = ( 1 + ((sint32)floor( rMaxU + 0.5 )) - ((sint32)floor( rMinU - 0.5 )) );
sint32 h = ( 1 + ((sint32)floor( rMaxV + 0.5 )) - ((sint32)floor( rMinV - 0.5 )) );
ResizeLMPlane( Plane, w, h );
Plane.x = ( ((sint32)floor( rMinU - 0.5 )) );
Plane.y = ( ((sint32)floor( rMinV - 0.5 )) );
for( j = 0; j < Plane.w*Plane.h; ++j )
Plane.msk[j] = 0;
ItParseI = ItFace;
for( i = 0; i < nNbFace; ++i )
{
pF = *ItParseI;
// Create Mask
SLMPlane Piece;
CreateLMPlaneFromFace( Piece, pF );
// Because all is in absolute coordinate
Piece.x -= Plane.x;
Piece.y -= Plane.y;
PutLMPlaneInLMPlane( Plane, Piece );
++ItParseI;
}
}
// -----------------------------------------------------------------------------------------------
void ModifyLMPlaneWithOverSampling( SLMPlane *pPlane, double rOverSampling )
{
sint32 i, j;
vector<CMesh::CFace*>::iterator ItFace = pPlane->faces.begin();
sint32 nNbFace = pPlane->faces.size();
stretchLMPlane( pPlane, rOverSampling );
for( j = 0; j < pPlane->w*pPlane->h; ++j ) // Reset the mask
pPlane->msk[j] = 0;
MultiplyFaceUV1( ItFace, nNbFace, rOverSampling );
ItFace = pPlane->faces.begin();
// Recreate the form
for( i = 0; i < nNbFace; ++i )
{
CMesh::CFace *pF = *ItFace;
SLMPlane Piece;
CreateLMPlaneFromFace( Piece, pF );
Piece.x -= pPlane->x;
Piece.y -= pPlane->y;
PutLMPlaneInLMPlane( *pPlane, Piece, true );
++ItFace;
}
}
// -----------------------------------------------------------------------------------------------
void PlaceLMPlaneInLMPLane( SLMPlane &Dst, SLMPlane &Src )
{
while( true )
{
if( !TryAllPosForLMPlaneInLMPlane( Dst, Src ) )
{
if( ( Dst.w < MAXLIGHTMAPSIZE ) || ( Dst.h < MAXLIGHTMAPSIZE ) )
{
if( Dst.w < Dst.h )
ResizeLMPlane( Dst, Dst.w*2, Dst.h );
else
ResizeLMPlane( Dst, Dst.w, Dst.h*2 );
}
else
{
// ERROR: we reached the maximum texture size
nlstop;
}
}
else
{
// We found a position
PutLMPlaneInLMPlane( Dst, Src );
break;
}
}
}
// -----------------------------------------------------------------------------------------------
void CalculateGradient( SGradient &g, CMesh::CFace *pF, vector<CVector>& vVertices, CVector &n1, CVector &n2, CVector &n3 )
{
double u1 = pF->Corner[0].Uvws[1].U,
v1 = pF->Corner[0].Uvws[1].V,
u2 = pF->Corner[1].Uvws[1].U,
v2 = pF->Corner[1].Uvws[1].V,
u3 = pF->Corner[2].Uvws[1].U,
v3 = pF->Corner[2].Uvws[1].V;
CVector p1 = vVertices[pF->Corner[0].Vertex],
p2 = vVertices[pF->Corner[1].Vertex],
p3 = vVertices[pF->Corner[2].Vertex];
double GradDen = 1.0 / ( (u3-u1)*(v2-v1) - (u2-u1)*(v3-v1) );
g.InitU = u1;
g.InitV = v1;
g.InitPx = p1.x;
g.InitPy = p1.y;
g.InitPz = p1.z;
g.InitNx = n1.x;
g.InitNy = n1.y;
g.InitNz = n1.z;
// Gradients for the vertex
g.GraduPx = ( (p3.x-p1.x)*(v2-v1)-(p2.x-p1.x)*(v3-v1) ) * GradDen;
g.GradvPx = ( (p2.x-p1.x)*(u3-u1)-(p3.x-p1.x)*(u2-u1) ) * GradDen;
g.GraduPy = ( (p3.y-p1.y)*(v2-v1)-(p2.y-p1.y)*(v3-v1) ) * GradDen;
g.GradvPy = ( (p2.y-p1.y)*(u3-u1)-(p3.y-p1.y)*(u2-u1) ) * GradDen;
g.GraduPz = ( (p3.z-p1.z)*(v2-v1)-(p2.z-p1.z)*(v3-v1) ) * GradDen;
g.GradvPz = ( (p2.z-p1.z)*(u3-u1)-(p3.z-p1.z)*(u2-u1) ) * GradDen;
// The same for the normal
g.GraduNx = ( (n3.x-n1.x)*(v2-v1)-(n2.x-n1.x)*(v3-v1) ) * GradDen;
g.GradvNx = ( (n2.x-n1.x)*(u3-u1)-(n3.x-n1.x)*(u2-u1) ) * GradDen;
g.GraduNy = ( (n3.y-n1.y)*(v2-v1)-(n2.y-n1.y)*(v3-v1) ) * GradDen;
g.GradvNy = ( (n2.y-n1.y)*(u3-u1)-(n3.y-n1.y)*(u2-u1) ) * GradDen;
g.GraduNz = ( (n3.z-n1.z)*(v2-v1)-(n2.z-n1.z)*(v3-v1) ) * GradDen;
g.GradvNz = ( (n2.z-n1.z)*(u3-u1)-(n3.z-n1.z)*(u2-u1) ) * GradDen;
}
// -----------------------------------------------------------------------------------------------
CVector CalculateInterpolatedVertex( SGradient &g, double u, double v )
{
CVector vRet;
vRet.x = (float)(g.GraduPx*(u-g.InitU) + g.GradvPx*(v-g.InitV) + g.InitPx);
vRet.y = (float)(g.GraduPy*(u-g.InitU) + g.GradvPy*(v-g.InitV) + g.InitPy);
vRet.z = (float)(g.GraduPz*(u-g.InitU) + g.GradvPz*(v-g.InitV) + g.InitPz);
return vRet;
}
// -----------------------------------------------------------------------------------------------
CVector CalculateInterpolatedNormal( SGradient &g, double u, double v )
{
CVector vRet;
vRet.x = (float)(g.GraduNx*(u-g.InitU) + g.GradvNx*(v-g.InitV) + g.InitNx);
vRet.y = (float)(g.GraduNy*(u-g.InitU) + g.GradvNy*(v-g.InitV) + g.InitNy);
vRet.z = (float)(g.GraduNz*(u-g.InitU) + g.GradvNz*(v-g.InitV) + g.InitNz);
vRet.normalize();
return vRet;
}
// -----------------------------------------------------------------------------------------------
float TestRay( CVector &vLightPos, CVector &vVertexPos, SWorldRT &wrt, sint32 nLightNb )
{
// Optim avec Cube Grid
wrt.cgAccel[nLightNb].select( vVertexPos - vLightPos );
while( !wrt.cgAccel[nLightNb].isEndSel() )
{
SCubeGridCell cell = wrt.cgAccel[nLightNb].getSel();
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 ) )
{
return 0.0f;
}
// Next selected element
wrt.cgAccel[nLightNb].nextSel();
}
return 1.0f;
/* // Optim avec BSP
for( sint32 i = 0; i < wrt.bbBoxes.size(); ++i )
{
if( wrt.bbBoxes[i].intersect( rayP1, rayP2, rayP2 ) )
{
sint32 nNbSel = wrt.btAccel[i].select( rayP1, rayP2 );
for( sint32 j = 0; j < nNbSel; ++j )
{
SWorldRTCell cell = wrt.btAccel[i].getSelection( j );
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( rayP1, rayP2, hit, plane ) )
{
return 0.0f;
}
}
}
}
return 1.0f;*/
/*// Optim avec quad tree
for( sint32 i = 0; i < wrt.bbBoxes.size(); ++i )
{
if( wrt.bbBoxes[i].intersect( rayP1, rayP2, rayP2 ) )
{
wrt.qtAccel[i].selectSegment( rayP1, rayP2 );
CQuadTree<SWorldRTCell>::CIterator it = wrt.qtAccel[i].begin();
while( it != wrt.qtAccel[i].end() )
{
SWorldRTCell cell = *it;
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( rayP1, rayP2, hit, plane ) )
{
return 0.0f;
}
// Next selected element
++it;
}
}
}
return 1.0f;*/
/* // No optim
for( sint32 i = 0; i < Meshes.size(); ++i )
{
CMesh::CMeshBuild *pMB = Meshes[i].first;
// Test the ray with the bsphere first
if( segmentIntersectBSphere( rayP1, rayP2, Meshes[i].second ) )
{
CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
for( sint32 j = 0; j < pMB->Faces.size(); ++j )
{
CVector hit;
CTriangle t(MBMatrix * pMB->Vertices[pMB->Faces[j].Corner[0].Vertex],
MBMatrix * pMB->Vertices[pMB->Faces[j].Corner[1].Vertex],
MBMatrix * pMB->Vertices[pMB->Faces[j].Corner[2].Vertex] );
CPlane plane;
plane.make( t.V0, t.V1, t.V2 );
if( t.intersect( rayP1, rayP2, hit, plane ) )
{
return 0.0f;
}
}
}
}*/
}
// -----------------------------------------------------------------------------------------------
float RayTraceAVertex( CVector &p, SWorldRT &wrt, sint32 nLightNb, SLightBuild& rLight )
{
double rFactor = 0.0;
sint32 nLightForFactor = 0;
TTicks zeTime = CTime::getPerformanceTime();
switch( rLight.Type )
{
case SLightBuild::LightAmbient:
rFactor = 1.0;
break;
case SLightBuild::LightSpot:
case SLightBuild::LightPoint:
{
CVector light_p = p - rLight.Position;
float light_p_distance = light_p.norm();
light_p_distance = light_p_distance - (0.01+(0.05*light_p_distance/100.0)); // Substract n centimeter
light_p.normalize();
light_p *= light_p_distance;
rFactor = TestRay( rLight.Position, rLight.Position + light_p, wrt, nLightNb );
nLightForFactor++;
}
break;
case SLightBuild::LightDir:
/*
{
CVector r1 = p-rLight.Direction/100;
CVector r2 = p-100*rLight.Direction;
rFactor = TestRay( r1, r2, wrt );
nLightForFactor++;
}
*/
rFactor = 1.0; // Not done for the moment
break;
default:
break;
}
timerCalcRT += CTime::getPerformanceTime() - zeTime;
if( rFactor > 0.0 )
return 1.0f;
else
return 0.0f;
//return rFactor / ((double)nLightForFactor);
}
// -----------------------------------------------------------------------------------------------
CRGBAF LightAVertex( CVector &pRT, CVector &p, CVector &n,
vector<sint32> &vLights, vector<SLightBuild> &AllLights,
SWorldRT &wrt, bool bDoubleSided )
{
CRGBAF rgbafRet;
rgbafRet.R = rgbafRet.G = rgbafRet.B = rgbafRet.A = 0.0;
// Color calculation
for( uint32 nLight = 0; nLight < vLights.size(); ++nLight )
{
SLightBuild &rLight = AllLights[vLights[nLight]];
CRGBAF lightAmbiCol = CRGBAF(0.0f, 0.0f, 0.0f, 0.0f);
CRGBAF lightDiffCol = CRGBAF(0.0f, 0.0f, 0.0f, 0.0f);
CRGBAF lightSpecCol = CRGBAF(0.0f, 0.0f, 0.0f, 0.0f);
float factor = 0.0;
float light_intensity = 0.0;
switch( rLight.Type )
{
case SLightBuild::LightAmbient:
lightAmbiCol.R = rLight.Ambient.R / 255.0f;
lightAmbiCol.G = rLight.Ambient.G / 255.0f;
lightAmbiCol.B = rLight.Ambient.B / 255.0f;
lightAmbiCol.A = rLight.Ambient.A / 255.0f;
light_intensity = 1.0;
break;
case SLightBuild::LightPoint:
{
CVector p_light = rLight.Position - p;
float p_light_distance = p_light.norm();
if( p_light_distance < rLight.rRadiusMin )
light_intensity = 1.0f;
else
if( p_light_distance > rLight.rRadiusMax )
light_intensity = 0.0f;
else
light_intensity = 1.0f - (p_light_distance-rLight.rRadiusMin)/(rLight.rRadiusMax-rLight.rRadiusMin);
p_light.normalize();
// ??? light_intensity *= light_intensity * light_intensity;
if( bDoubleSided && (n*p_light < 0.0f) )
{
p_light = -p_light;
}
light_intensity *= max(0.0f, n*p_light);
lightDiffCol.R = light_intensity * rLight.Diffuse.R / 255.0f;
lightDiffCol.G = light_intensity * rLight.Diffuse.G / 255.0f;
lightDiffCol.B = light_intensity * rLight.Diffuse.B / 255.0f;
lightDiffCol.A = light_intensity * rLight.Diffuse.A / 255.0f;
}
break;
case SLightBuild::LightDir:
{
CVector p_light = - rLight.Direction;
p_light.normalize();
if( bDoubleSided && (n*p_light < 0.0f) )
{
p_light = -p_light;
}
light_intensity = max(0.0f, n*p_light);
lightDiffCol.R = light_intensity * rLight.Diffuse.R / 255.0f;
lightDiffCol.G = light_intensity * rLight.Diffuse.G / 255.0f;
lightDiffCol.B = light_intensity * rLight.Diffuse.B / 255.0f;
lightDiffCol.A = light_intensity * rLight.Diffuse.A / 255.0f;
}
break;
case SLightBuild::LightSpot:
{
CVector p_light = rLight.Position - p;
float p_light_distance = p_light.norm();
if( p_light_distance < rLight.rRadiusMin )
light_intensity = 1.0f;
else
if( p_light_distance > rLight.rRadiusMax )
light_intensity = 0.0f;
else
light_intensity = 1.0f - (p_light_distance-rLight.rRadiusMin)/(rLight.rRadiusMax-rLight.rRadiusMin);
p_light.normalize();
float ang = acosf( p_light * (-rLight.Direction) );
if( ang > rLight.rFallof )
light_intensity = 0.0f;
else
if( ang > rLight.rHotspot )
light_intensity *= 1.0f - (ang-rLight.rHotspot)/(rLight.rFallof-rLight.rHotspot);
// ??? light_intensity *= light_intensity * light_intensity;
if( bDoubleSided && (n*p_light < 0.0f) )
{
p_light = -p_light;
}
light_intensity *= max(0.0f, n*p_light);
lightDiffCol.R = light_intensity * rLight.Diffuse.R / 255.0f;
lightDiffCol.G = light_intensity * rLight.Diffuse.G / 255.0f;
lightDiffCol.B = light_intensity * rLight.Diffuse.B / 255.0f;
lightDiffCol.A = light_intensity * rLight.Diffuse.A / 255.0f;
}
break;
default:
break;
}
if( light_intensity > 0.0f )
{
if( ( rLight.bCastShadow ) && ( theExportSceneStruct.bShadow ) )
factor = RayTraceAVertex( pRT, wrt, vLights[nLight], rLight );
else
factor = 1.0f;
factor *= rLight.rMult;
}
rgbafRet.R += lightAmbiCol.R + lightDiffCol.R * factor;
if( rgbafRet.R > 1.0f ) rgbafRet.R = 1.0;
rgbafRet.G += lightAmbiCol.G + lightDiffCol.G * factor;
if( rgbafRet.G > 1.0f ) rgbafRet.G = 1.0;
rgbafRet.B += lightAmbiCol.B + lightDiffCol.B * factor;
if( rgbafRet.B > 1.0f ) rgbafRet.B = 1.0;
rgbafRet.A += lightAmbiCol.A + lightDiffCol.A * factor;
if( rgbafRet.A > 1.0f ) rgbafRet.A = 1.0;
}
return rgbafRet;
}
// -----------------------------------------------------------------------------------------------
CVector CalcInterpolatedVertexInFace( SGradient &g, double Uin, double Vin, CMesh::CFace *pF )
{
double Uout, Vout;
double Utmp, Vtmp;
double u1 = pF->Corner[0].Uvws[1].U, v1 = pF->Corner[0].Uvws[1].V;
double u2 = pF->Corner[1].Uvws[1].U, v2 = pF->Corner[1].Uvws[1].V;
double u3 = pF->Corner[2].Uvws[1].U, v3 = pF->Corner[2].Uvws[1].V;
double rDist = 10000000.0f, rDistTmp, factor;
// Get the nearest point from (Uin,Vin) to the face pF
rDistTmp = sqrt( (Uin-u1)*(Uin-u1) + (Vin-v1)*(Vin-v1) );
if( rDistTmp < rDist )
{
rDist = rDistTmp;
Uout = u1; Vout = v1;
}
rDistTmp = sqrt( (Uin-u2)*(Uin-u2) + (Vin-v2)*(Vin-v2) );
if( rDistTmp < rDist )
{
rDist = rDistTmp;
Uout = u2; Vout = v2;
}
rDistTmp = sqrt( (Uin-u3)*(Uin-u3) + (Vin-v3)*(Vin-v3) );
if( rDistTmp < rDist )
{
rDist = rDistTmp;
Uout = u3; Vout = v3;
}
factor = ( (Uin-u1)*(u2-u1) + (Vin-v1)*(v2-v1) ) / ( (u2-u1)*(u2-u1) + (v2-v1)*(v2-v1) );
if( ( factor >= 0.0 ) && ( factor <= 1.0 ) )
{
Utmp = u1+(u2-u1)*factor; Vtmp = v1+(v2-v1)*factor;
rDistTmp = sqrt( (Uin-Utmp)*(Uin-Utmp) + (Vin-Vtmp)*(Vin-Vtmp) );
if( rDistTmp < rDist )
{ rDist = rDistTmp; Uout = Utmp; Vout = Vtmp; }
}
factor = ( (Uin-u2)*(u3-u2) + (Vin-v2)*(v3-v2) ) / ( (u3-u2)*(u3-u2) + (v3-v2)*(v3-v2) );
if( ( factor >= 0.0 ) && ( factor <= 1.0 ) )
{
Utmp = u2+(u3-u2)*factor; Vtmp = v2+(v3-v2)*factor;
rDistTmp = sqrt( (Uin-Utmp)*(Uin-Utmp) + (Vin-Vtmp)*(Vin-Vtmp) );
if( rDistTmp < rDist )
{ rDist = rDistTmp; Uout = Utmp; Vout = Vtmp; }
}
factor = ( (Uin-u3)*(u1-u3) + (Vin-v3)*(v1-v3) ) / ( (u1-u3)*(u1-u3) + (v1-v3)*(v1-v3) );
if( ( factor >= 0.0 ) && ( factor <= 1.0 ) )
{
Utmp = u3+(u1-u3)*factor; Vtmp = v3+(v1-v3)*factor;
rDistTmp = sqrt( (Uin-Utmp)*(Uin-Utmp) + (Vin-Vtmp)*(Vin-Vtmp) );
if( rDistTmp < rDist )
{ rDist = rDistTmp; Uout = Utmp; Vout = Vtmp; }
}
// Calculate the 3d point
return CalculateInterpolatedVertex( g, Uout, Vout );
}
// -----------------------------------------------------------------------------------------------
bool segmentIntersectBSphere( CVector &p1, CVector &p2, CBSphere &bs )
{
// Is one point is in the sphere ?
CVector r = bs.Center - p1;
float f;
if( r.norm() <= bs.Radius )
return true;
r = bs.Center - p2;
if( r.norm() <= bs.Radius )
return true;
// Is the orthogonal projection of the center on the segment is in the sphere ?
r = p2 - p1;
f = r.norm();
f = ( r * (bs.Center - p1) ) / ( f * f );
if( ( f >= 0.0 ) && ( f <= 1.0 ) )
{
r = bs.Center - (p1 + r*f);
if( r.norm() <= bs.Radius )
return true;
}
return false;
}
// -----------------------------------------------------------------------------------------------
void FirstLight( CMesh::CMeshBuild* pMB, SLMPlane &Plane, vector<CVector> &vVertices,
CMatrix& ToWorldMat, vector<sint32> &vLights, vector<SLightBuild> &AllLights,
sint32 nLayerNb, SWorldRT &wrt )
{
// Fill interiors
vector<CMesh::CFace*>::iterator ItFace = Plane.faces.begin();
sint32 nNbFace = Plane.faces.size();
sint32 i, j, k;
double rMinU = 1000000.0, rMaxU = -1000000.0, rMinV = 1000000.0, rMaxV = -1000000.0;
sint32 nPosMinU, nPosMaxU, nPosMinV, nPosMaxV;
CMesh::CFace *pF;
SGradient g;
for( i = 0; i < Plane.w*Plane.h; ++i )
if( Plane.msk[i] != 0 )
Plane.msk[i] = 1;
for( i = 0; i < nNbFace; ++i )
{
pF = *ItFace;
bool doubleSided = pMB->Materials[pF->MaterialId].detDoubleSided();
// Select bounding square of the triangle
for( j = 0; j < 3; ++j )
{
if( rMinU > pF->Corner[j].Uvws[1].U ) rMinU = pF->Corner[j].Uvws[1].U;
if( rMaxU < pF->Corner[j].Uvws[1].U ) rMaxU = pF->Corner[j].Uvws[1].U;
if( rMinV > pF->Corner[j].Uvws[1].V ) rMinV = pF->Corner[j].Uvws[1].V;
if( rMaxV < pF->Corner[j].Uvws[1].V ) rMaxV = pF->Corner[j].Uvws[1].V;
}
nPosMaxU = ((sint32)floor( rMaxU + 0.5 ));
nPosMaxV = ((sint32)floor( rMaxV + 0.5 ));
nPosMinU = ((sint32)floor( rMinU - 0.5 ));
nPosMinV = ((sint32)floor( rMinV - 0.5 ));
CVector n1 = ToWorldMat.mulVector( pF->Corner[0].Normal );
CVector n2 = ToWorldMat.mulVector( pF->Corner[1].Normal );
CVector n3 = ToWorldMat.mulVector( pF->Corner[2].Normal );
CalculateGradient( g, pF, vVertices, n1, n2, n3 );
// Process all the interior
for( k = nPosMinV; k <= nPosMaxV; ++k )
for( j = nPosMinU; j <= nPosMaxU; ++j )
{
if( isInTriangleOrEdge( j+0.5, k+0.5,
pF->Corner[0].Uvws[1].U, pF->Corner[0].Uvws[1].V,
pF->Corner[1].Uvws[1].U, pF->Corner[1].Uvws[1].V,
pF->Corner[2].Uvws[1].U, pF->Corner[2].Uvws[1].V ) )
{
CVector p = CalculateInterpolatedVertex( g, j+0.5, k+0.5);
CVector n = CalculateInterpolatedNormal( g, j+0.5, k+0.5);
CRGBAF col = LightAVertex( p, p, n, vLights, AllLights, wrt, doubleSided );
Plane.col[j-Plane.x + (k-Plane.y)*Plane.w].p[nLayerNb].R = col.R;
Plane.col[j-Plane.x + (k-Plane.y)*Plane.w].p[nLayerNb].G = col.G;
Plane.col[j-Plane.x + (k-Plane.y)*Plane.w].p[nLayerNb].B = col.B;
Plane.col[j-Plane.x + (k-Plane.y)*Plane.w].p[nLayerNb].A = 1.0f;
// Darken the plane to indicate pixel is calculated
Plane.msk[j-Plane.x + (k-Plane.y)*Plane.w] = 2;
}
}
// Next Face
++ItFace;
}
}
// -----------------------------------------------------------------------------------------------
void SecondLight( CMesh::CMeshBuild*pMB, vector<SLMPlane*>::iterator ItPlanes, sint32 nNbPlanes,
vector<CVector> &vVertices, CMatrix& ToWorldMat,
vector<sint32> &vLights, vector<SLightBuild> &AllLights,
sint32 nLayerNb, SWorldRT &wrt)
{
// Fill interiors
sint32 i, j, k;
sint32 nPosMinU, nPosMaxU, nPosMinV, nPosMaxV;
SGradient g;
vector<SLMPlane*>::iterator ItPlanes1 = ItPlanes;
for( sint32 nPlanes1 = 0; nPlanes1 < nNbPlanes; ++nPlanes1 )
{
SLMPlane *pPlane1 = *ItPlanes1;
vector<CMesh::CFace*>::iterator ItParseI = pPlane1->faces.begin();
sint32 nNbFace1 = pPlane1->faces.size();
for( i = 0; i < nNbFace1; ++i )
{
CMesh::CFace *pF1 = *ItParseI;
double rMinU = 1000000.0, rMaxU = -1000000.0, rMinV = 1000000.0, rMaxV = -1000000.0;
bool doubleSided = pMB->Materials[pF1->MaterialId].detDoubleSided();
// Select bounding square of the triangle
for( j = 0; j < 3; ++j )
{
if( rMinU > pF1->Corner[j].Uvws[1].U ) rMinU = pF1->Corner[j].Uvws[1].U;
if( rMaxU < pF1->Corner[j].Uvws[1].U ) rMaxU = pF1->Corner[j].Uvws[1].U;
if( rMinV > pF1->Corner[j].Uvws[1].V ) rMinV = pF1->Corner[j].Uvws[1].V;
if( rMaxV < pF1->Corner[j].Uvws[1].V ) rMaxV = pF1->Corner[j].Uvws[1].V;
}
nPosMaxU = ((sint32)floor( rMaxU + 0.5 ));
nPosMaxV = ((sint32)floor( rMaxV + 0.5 ));
nPosMinU = ((sint32)floor( rMinU - 0.5 ));
nPosMinV = ((sint32)floor( rMinV - 0.5 ));
CVector n1 = ToWorldMat.mulVector( pF1->Corner[0].Normal );
CVector n2 = ToWorldMat.mulVector( pF1->Corner[1].Normal );
CVector n3 = ToWorldMat.mulVector( pF1->Corner[2].Normal );
CalculateGradient( g, pF1, vVertices, n1, n2, n3 );
double lumx1 = pF1->Corner[0].Uvws[1].U, lumy1 = pF1->Corner[0].Uvws[1].V,
lumx2 = pF1->Corner[1].Uvws[1].U, lumy2 = pF1->Corner[1].Uvws[1].V,
lumx3 = pF1->Corner[2].Uvws[1].U, lumy3 = pF1->Corner[2].Uvws[1].V;
// Process all the exterior and try to link with other planes
for( k = nPosMinV; k < nPosMaxV; ++k )
for( j = nPosMinU; j < nPosMaxU; ++j )
if( ( pPlane1->msk[j-pPlane1->x + (k-pPlane1->y)*pPlane1->w] == 1 ) ||
( pPlane1->msk[1+j-pPlane1->x + (k-pPlane1->y)*pPlane1->w] == 1 ) ||
( pPlane1->msk[1+j-pPlane1->x + (1+k-pPlane1->y)*pPlane1->w] == 1 ) ||
( pPlane1->msk[j-pPlane1->x + (1+k-pPlane1->y)*pPlane1->w] == 1 ) )
if( segmentIntersection(j+0.5, k+0.5, j+1.5, k+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(j+0.5, k+0.5, j+1.5, k+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(j+0.5, k+0.5, j+1.5, k+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(j+0.5, k+0.5, j+0.5, k+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(j+0.5, k+0.5, j+0.5, k+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(j+0.5, k+0.5, j+0.5, k+1.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(j+1.5, k+1.5, j+1.5, k+0.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(j+1.5, k+1.5, j+1.5, k+0.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(j+1.5, k+1.5, j+1.5, k+0.5, lumx3, lumy3, lumx1, lumy1) ||
segmentIntersection(j+1.5, k+1.5, j+0.5, k+1.5, lumx1, lumy1, lumx2, lumy2) ||
segmentIntersection(j+1.5, k+1.5, j+0.5, k+1.5, lumx2, lumy2, lumx3, lumy3) ||
segmentIntersection(j+1.5, k+1.5, j+0.5, k+1.5, lumx3, lumy3, lumx1, lumy1) )
{
// If all segment of the current face are linked with a face in this plane, no need to continue
vector<CMesh::CFace*>::iterator ItParseM = pPlane1->faces.begin();
sint32 nNbSeg = 0;
uint32 m, n;
for( m = 0; m < nNbFace1; ++m )
{
CMesh::CFace *pF2 = *ItParseM;
if( m != i )
if( FaceContinuous( pF1, pF2 ) )
++nNbSeg;
++ItParseM;
}
if( nNbSeg >= 3 )
continue;
// Get the face on the other plane with a common segment
vector<SLMPlane*>::iterator ItParsePlanes = ItPlanes;
for( m = 0; m < nNbPlanes; ++m )
{
SLMPlane *pPlane2 = *ItParsePlanes;
if( pPlane2 != pPlane1 )
for( n = 0; n < pPlane2->faces.size(); ++n )
{
CMesh::CFace *pF2 = pPlane2->faces[n];
if( FaceContinuous( pF1, pF2 ) )
{
for( sint32 o = 0; o < 4; ++o )
{
sint32 nAbsX = j + (o/2), nAbsY = k + (o%2);
// Is it a pixel to treat and pixel in the 2nd plane
if( ( pPlane1->msk[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w] == 1 ) &&
(nAbsX >= pPlane2->x) && (nAbsX < (pPlane2->x+pPlane2->w) ) &&
(nAbsY >= pPlane2->y) && (nAbsY < (pPlane2->y+pPlane2->h) ) )
{
// Is it an interior calculated pixel ?
if( pPlane2->msk[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w] == 2 )
{ // Yes -> ok so get it
pPlane1->col[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w].p[nLayerNb] =
pPlane2->col[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w].p[nLayerNb];
pPlane1->msk[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w] = 3;
}
else
if( pPlane2->msk[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w] == 1 )
{ // No -> Add extrapolated value
CVector iv = CalculateInterpolatedVertex( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5);
CVector in = CalculateInterpolatedNormal( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5);
CVector rv = CalcInterpolatedVertexInFace( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5, pF1 );
CRGBAF col = LightAVertex( rv, iv, in, vLights, AllLights, wrt, doubleSided );
//float f = 1.0f;
pPlane2->col[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w].p[nLayerNb].R += col.R;
pPlane2->col[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w].p[nLayerNb].G += col.G;
pPlane2->col[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w].p[nLayerNb].B += col.B;
pPlane2->col[nAbsX-pPlane2->x + (nAbsY-pPlane2->y)*pPlane2->w].p[nLayerNb].A += 1.0f;
}
}
}
}
}
++ItParsePlanes;
}
for( sint32 o = 0; o < 4; ++o )
{
sint32 nAbsX = j + (o/2), nAbsY = k + (o%2);
if( pPlane1->msk[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w] == 1 )
{
CVector iv = CalculateInterpolatedVertex( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5);
CVector in = CalculateInterpolatedNormal( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5);
CVector rv = CalcInterpolatedVertexInFace( g, ((double)nAbsX)+0.5, ((double)nAbsY)+0.5, pF1 );
CRGBAF col = LightAVertex( rv, iv, in, vLights, AllLights, wrt, doubleSided );
//float f = 1.0f;
pPlane1->col[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w].p[nLayerNb].R += col.R;
pPlane1->col[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w].p[nLayerNb].G += col.G;
pPlane1->col[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w].p[nLayerNb].B += col.B;
pPlane1->col[nAbsX-pPlane1->x + (nAbsY-pPlane1->y)*pPlane1->w].p[nLayerNb].A += 1.0f;
}
}
}
// Next Face
++ItParseI;
}
++ItPlanes1;
}
// All planes are done so now we have to average the value of lumels grouping severals normals
ItPlanes1 = ItPlanes;
for( nPlanes1 = 0; nPlanes1 < nNbPlanes; ++nPlanes1 )
{
SLMPlane *pPlane1 = *ItPlanes1;
for( k = 0; k < pPlane1->h; ++k )
for( j = 0; j < pPlane1->w; ++j )
{
if( pPlane1->msk[j+k*pPlane1->w] == 1 )
{
sint32 nNbNormals = pPlane1->col[j + k*pPlane1->w].p[nLayerNb].A;
pPlane1->col[j + k*pPlane1->w].p[nLayerNb].R /= nNbNormals;
pPlane1->col[j + k*pPlane1->w].p[nLayerNb].G /= nNbNormals;
pPlane1->col[j + k*pPlane1->w].p[nLayerNb].B /= nNbNormals;
pPlane1->col[j + k*pPlane1->w].p[nLayerNb].A = 1.0f;
pPlane1->msk[j + k*pPlane1->w] = 4;
}
}
++ItPlanes1;
}
}
// -----------------------------------------------------------------------------------------------
bool IsAllFaceMapped( vector<CMesh::CFace*>::iterator ItFace, sint32 nNbFaces )
{
sint32 i, j;
vector<CMesh::CFace*>::iterator ItParseI = ItFace;
for( i = 0; i < nNbFaces; ++i )
{
CMesh::CFace *pF = *ItParseI;
for( j = 0; j < 3; ++j )
{
if( (fabsf(pF->Corner[j].Uvws[1].U) > 64.0) ||
(fabsf(pF->Corner[j].Uvws[1].V) > 64.0) )
return false;
}
++ItParseI;
}
double TextureSurf = 0.0f;
ItParseI = ItFace;
for( i = 0; i < nNbFaces; ++i )
{
CMesh::CFace *pF = *ItParseI;
CVector p1, p2, p3;
p1.x = pF->Corner[0].Uvws[1].U; p1.y = pF->Corner[0].Uvws[1].V; p1.z = 0.0f;
p2.x = pF->Corner[1].Uvws[1].U; p2.y = pF->Corner[1].Uvws[1].V; p2.z = 0.0f;
p3.x = pF->Corner[2].Uvws[1].U; p3.y = pF->Corner[2].Uvws[1].V; p3.z = 0.0f;
TextureSurf += calculateTriangleSurface( p1, p2, p3 );
++ItParseI;
}
if( fabsf(TextureSurf) < 0.000001 )
return false;
return true;
}
// -----------------------------------------------------------------------------------------------
CAABBox getMeshBBox( CMesh::CMeshBuild& rMB, bool bNeedToTransform )
{
CAABBox meshBox;
if( bNeedToTransform )
{
CMatrix MBMatrix = getObjectToWorldMatrix( &rMB );
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] );
}
else
{
for( uint32 j = 0; j < rMB.Vertices.size(); ++j )
if( j == 0 )
meshBox.setCenter( rMB.Vertices[j] );
else
meshBox.extend( rMB.Vertices[j] );
}
return meshBox;
}
// -----------------------------------------------------------------------------------------------
CAABBox getLightBBox( CVector &vPos, float rRadius )
{
CAABBox lightBox;
lightBox.setCenter( vPos );
lightBox.extend( vPos - CVector(rRadius,0,0) );
lightBox.extend( vPos + CVector(rRadius,0,0) );
lightBox.extend( vPos - CVector(0,rRadius,0) );
lightBox.extend( vPos + CVector(0,rRadius,0) );
lightBox.extend( vPos - CVector(0,0,rRadius) );
lightBox.extend( vPos + CVector(0,0,rRadius) );
return lightBox;
}
// -----------------------------------------------------------------------------------------------
bool isLightCanCastShadowOnBox( SLightBuild &rSLB, CAABBox &b )
{
switch( rSLB.Type )
{
case SLightBuild::LightAmbient: // No need an ambient light...
// No ambient handled for the moment
break;
case SLightBuild::LightSpot: // For the moment spot like point
case SLightBuild::LightPoint:
{
CAABBox lightBox = getLightBBox( rSLB.Position, rSLB.rRadiusMax );
if( lightBox.intersect( b ) )
return true;
if( b.include( lightBox.getMin() ) )
return true;
if( lightBox.include( b.getMin() ) )
return true;
}
break;
case SLightBuild::LightDir:
// Attenuation not handled (ask cyril later)
break;
}
return false;
}
// -----------------------------------------------------------------------------------------------
bool isInteractionLightMesh( SLightBuild &rSLB, CMesh::CMeshBuild &rMB )
{
CAABBox meshBox;
if( rSLB.Type == SLightBuild::LightAmbient )
return true;
meshBox = getMeshBBox( rMB, true );
return isLightCanCastShadowOnBox( rSLB, meshBox );
}
bool isInteractionLightMeshWithoutAmbient( SLightBuild &rSLB, CMesh::CMeshBuild &rMB )
{
CAABBox meshBox;
if( rSLB.Type == SLightBuild::LightAmbient )
return false;
meshBox = getMeshBBox( rMB, true );
return isLightCanCastShadowOnBox( rSLB, meshBox );
}
// -----------------------------------------------------------------------------------------------
// Get all lights that can cast shadows on the current mesh
void getLightInteract( CMesh::CMeshBuild* pMB, vector<SLightBuild> &AllLights, vector< vector<sint32> >&vvLights )
{
uint32 nNbGroup = 0;
vector<sint32> vlbTmp;
uint32 i, j;
for( i = 0; i < AllLights.size(); ++i )
{
if( isInteractionLightMesh( AllLights[i], *pMB ) )
{
// Is the light name already exist
for( j = 0; j < nNbGroup; ++j )
if( AllLights[vvLights[j].operator[](0)].GroupName == AllLights[i].GroupName )
break;
// The light name does not exist create a new group
if( ( j == nNbGroup ) && ( nNbGroup < 8 ) )
{
vvLights.push_back( vlbTmp ); // Static lighting
vvLights[nNbGroup].push_back( i );
++nNbGroup;
}
else
{ // The light name already exist or there is not enought groups
if( j == nNbGroup )
j = nNbGroup - 1;
vvLights[j].push_back( i );
}
}
}
}
// -----------------------------------------------------------------------------------------------
void GetAllNodeInScene( vector< CMesh::CMeshBuild* > &Meshes, vector<SLightBuild> &AllLights, INode* pNode = NULL )
{
if( pNode == NULL )
pNode = theCNelExport.ip->GetRootNode();
// Get a pointer on the object's node
TimeValue tvTime = theCNelExport.ip->GetTime();
if( ! RPO::isZone( *pNode, tvTime ) )
if( CExportNel::isMesh( *pNode, tvTime ) )
{
CMesh::CMeshBuild *pMB;
pMB = CExportNel::createMeshBuild( *pNode, tvTime );
// If the mesh has no interaction with one of the light selected we do not need it
bool bInteract = false;
for( uint32 i = 0; i < AllLights.size(); ++i )
if( isInteractionLightMeshWithoutAmbient( AllLights[i], *pMB ) )
{
bInteract = true;
break;
}
if( bInteract )
Meshes.push_back( pMB );
else
delete pMB; // No interaction so delete the mesh
}
for( sint32 i = 0; i < pNode->NumberOfChildren(); ++i )
GetAllNodeInScene( Meshes, AllLights, pNode->GetChildNode(i) );
}
// -----------------------------------------------------------------------------------------------
void buildWorldRT( SWorldRT &wrt, vector<SLightBuild> &AllLights )
{
uint32 i, j, k;
// Get all the nodes in the scene
GetAllNodeInScene( wrt.vMB, AllLights );
// Transform the meshbuilds vertices and normals to have world coordinates
for( i = 0; i < wrt.vMB.size(); ++i )
{
CMatrix MBMatrix = getObjectToWorldMatrix( wrt.vMB[i] );
// Update vertices
for( j = 0; j < wrt.vMB[i]->Vertices.size(); ++j )
wrt.vMB[i]->Vertices[j] = MBMatrix * wrt.vMB[i]->Vertices[j];
// Update normals
MBMatrix.invert();
MBMatrix.transpose();
for( j = 0; j < wrt.vMB[i]->Faces.size(); ++j )
for( k = 0; k < 3 ; ++k )
wrt.vMB[i]->Faces[j].Corner[k].Normal =
MBMatrix.mulVector( wrt.vMB[i]->Faces[j].Corner[k].Normal );
}
// Construct all cube grids from all lights
wrt.cgAccel.resize( AllLights.size() );
for( i = 0; i < AllLights.size(); ++i )
{
wrt.cgAccel[i].create( 64 ); // width of each grid in number of square
switch( AllLights[i].Type )
{
case SLightBuild::LightAmbient:
// No ambient handled for the moment
break;
case SLightBuild::LightSpot: // For the moment spot like point
case SLightBuild::LightPoint:
{
for( j = 0; j < wrt.vMB.size(); ++j )
{
for( k = 0; k < wrt.vMB[j]->Faces.size(); ++k )
{
SCubeGridCell cell;
cell.pF = &(wrt.vMB[j]->Faces[k]);
cell.pMB = wrt.vMB[j];
CTriangle tri = CTriangle(
cell.pMB->Vertices[cell.pF->Corner[0].Vertex] - AllLights[i].Position,
cell.pMB->Vertices[cell.pF->Corner[1].Vertex] - AllLights[i].Position,
cell.pMB->Vertices[cell.pF->Corner[2].Vertex] - AllLights[i].Position );
if( intersectionTriangleSphere( tri, CBSphere(CVector(0,0,0), AllLights[i].rRadiusMax) ) )
wrt.cgAccel[i].insert( tri, cell );
}
}
}
break;
case SLightBuild::LightDir:
// No directionnal handled for the moment
break;
}
}
// Construct the aabboxes of the buildmeshes
/* wrt.bbBoxes.resize( wrt.vMB.size() );
for( i = 0; i < wrt.vMB.size(); ++i )
{
wrt.bbBoxes[i] = getMeshBBox( *wrt.vMB[i], false );
} */
/* // Construct the quad tree for each mesh
wrt.qtAccel.resize( wrt.vMB.size() );
for( i = 0; i < wrt.vMB.size(); ++i )
{
wrt.qtAccel[i].create( 4, wrt.bbBoxes[i].getCenter(), max(wrt.bbBoxes[i].getSize().x, wrt.bbBoxes[i].getSize().y) );
// Put the quadtree in the XY basis
CMatrix tmp;
CVector I( 1, 0, 0 );
CVector J( 0, 0, -1 );
CVector K( 0, 1, 0 );
tmp.identity();
tmp.setRot( I, J, K, true );
wrt.qtAccel[i].changeBase( tmp );
for( j = 0; j < wrt.vMB[i]->Faces.size(); ++j )
{
SWorldRTCell cell;
CAABBox bbFace;
cell.pF = &(wrt.vMB[i]->Faces[j]);
cell.pMB = wrt.vMB[i];
bbFace.setCenter( cell.pMB->Vertices[cell.pF->Corner[0].Vertex] );
bbFace.extend( cell.pMB->Vertices[cell.pF->Corner[1].Vertex] );
bbFace.extend( cell.pMB->Vertices[cell.pF->Corner[2].Vertex] );
wrt.qtAccel[i].insert( bbFace.getMin(), bbFace.getMax(), cell );
}
} */
/* // Construct the bsp tree for each mesh
wrt.btAccel.resize( wrt.vMB.size() );
for( i = 0; i < wrt.vMB.size(); ++i )
{
for( j = 0; j < wrt.vMB[i]->Faces.size(); ++j )
{
SWorldRTCell cell;
CTriangle tri;
cell.pF = &(wrt.vMB[i]->Faces[j]);
cell.pMB = wrt.vMB[i];
tri.V0 = cell.pMB->Vertices[cell.pF->Corner[0].Vertex];
tri.V1 = cell.pMB->Vertices[cell.pF->Corner[1].Vertex];
tri.V2 = cell.pMB->Vertices[cell.pF->Corner[2].Vertex];
wrt.btAccel[i].insert( tri, cell );
}
sint32 nNbNode = wrt.btAccel[i].getNbNode();
} */
}
// -----------------------------------------------------------------------------------------------
// Is the box b1 can cast shadow on the box b2 with the light l ?
bool isBoxCanCastShadowOnBoxWithLight( CAABBox &b1, CAABBox &b2, SLightBuild &l )
{
// if the light is included in the box b2
return isLightCanCastShadowOnBox( l, b1 );
}
// -----------------------------------------------------------------------------------------------
void supprLightNoInteract( vector<SLightBuild> &vLights,
vector< pair < CMesh::CMeshBuild*,INode* > > &AllSelectedMeshes )
{
uint32 i, j;
for( i = 0; i < vLights.size(); ++i )
{
bool bInteract = false;
for( j = 0; j < AllSelectedMeshes.size(); ++j )
if( isInteractionLightMesh( vLights[i], *AllSelectedMeshes[j].first ) )
{
bInteract = true;
break;
}
if( !bInteract )
{
// Suppress the light because it has no interaction with selected meshes
for( j = i; j < (vLights.size()-1); ++j )
vLights[j] = vLights[j+1];
vLights.resize(vLights.size()-1);
--i;
}
}
}
// -----------------------------------------------------------------------------------------------
void supprLightNoInteractOne( vector<SLightBuild> &vLights, CMesh::CMeshBuild* pMB)
{
uint32 i, j;
for( i = 0; i < vLights.size(); ++i )
{
bool bInteract = false;
if( isInteractionLightMesh( vLights[i], *pMB ) )
{
bInteract = true;
break;
}
if( !bInteract )
{
// Suppress the light because it has no interaction with selected meshes
for( j = i; j < (vLights.size()-1); ++j )
vLights[j] = vLights[j+1];
vLights.resize(vLights.size()-1);
--i;
}
}
}
// -----------------------------------------------------------------------------------------------
// Construct the world accelerator for raytrace
void buildWorldRTAccel( SWorldRT &wrt, CMesh::CMeshBuild* pMB, vector< vector<sint32> > &vvLights )
{
sint32 i, j, k;
// Determine all meshes that can cast shadows on the current mesh with current lights
/*
vector<sint32> allmesh;
CAABBox curBBox = getMeshBBox( *pMB, true );
for( j = 0; j < wrt.vMB.size(); ++j )
{
for( k = 0; k < vvLights.size(); ++k )
{
vector<SLightBuild*> &vLights = vvLights[k];
for( i = 0; i < vLights.size(); ++i )
{
if( isBoxCanCastShadowOnBoxWithLight( wrt.bbBoxes[j] , curBBox, *vLights[i] ) )
{
allmesh.push_back( j );
break;
}
}
}
}
// Clear the container
wrt.qtAccel.clear();
// Construct the accel
CAABBox bbWorld;
sint32 nNbVertices = 0;
// Get the BBox of all meshes that can cast shadow on the current mesh
for( i = 0; i < allmesh.size(); ++i )
{
nNbVertices += wrt.vMB[allmesh[i]]->Vertices.size();
for( j = 0; j < wrt.vMB[allmesh[i]]->Vertices.size(); ++j )
if( (j == 0) && ( i == 0 ) )
bbWorld.setCenter( wrt.vMB[allmesh[i]]->Vertices[j] );
else
bbWorld.extend( wrt.vMB[allmesh[i]]->Vertices[j] );
}
wrt.qtAccel.create( 9, bbWorld.getCenter(), max(bbWorld.getSize().x,bbWorld.getSize().y) );
// Put the quadtree in the XY basis
CMatrix tmp;
CVector I( 1, 0, 0 );
CVector J( 0, 0, -1 );
CVector K( 0, 1, 0 );
tmp.identity();
tmp.setRot( I, J, K, true );
wrt.qtAccel.changeBase( tmp );
for( i = 0; i < allmesh.size(); ++i )
{
for( j = 0; j < wrt.vMB[allmesh[i]]->Faces.size(); ++j )
{
SWorldRTCell cell;
CAABBox bbFace;
cell.pF = &(wrt.vMB[allmesh[i]]->Faces[j]);
cell.pMB = wrt.vMB[allmesh[i]];
bbFace.setCenter( cell.pMB->Vertices[cell.pF->Corner[0].Vertex] );
bbFace.extend( cell.pMB->Vertices[cell.pF->Corner[1].Vertex] );
bbFace.extend( cell.pMB->Vertices[cell.pF->Corner[2].Vertex] );
wrt.qtAccel.insert( bbFace.getMin(), bbFace.getMax(), cell );
}
}*/
}
volatile bool bCancelCalculation = false;
float gRatioCalculated;
DWORD gTimeBegin;
int CALLBACK CalculatingDialogCallback (
HWND hwndDlg, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
DWORD TimeCurrent = timeGetTime();
switch (uMsg)
{
case WM_INITDIALOG:
{
CenterWindow( hwndDlg, theCNelExport.ip->GetMAXHWnd() );
ShowWindow( hwndDlg, SW_SHOWNORMAL );
gRatioCalculated = 0.0;
gTimeBegin = timeGetTime();
bCancelCalculation = false;
}
break;
case WM_PAINT:
{
char temp[256];
SendMessage( GetDlgItem( hwndDlg, IDC_PROGRESS1 ), PBM_SETPOS, gRatioCalculated*100, 0 );
if( gRatioCalculated > 0.0 )
{
DWORD TimeLeft = ((TimeCurrent - gTimeBegin) / gRatioCalculated) * (1.0-gRatioCalculated);
sprintf( temp, "Time remaining : %02d h %02d m %02d s", TimeLeft/3600000,
(TimeLeft/60000)%60,
(TimeLeft/1000)%60 );
SendMessage( GetDlgItem( hwndDlg, IDC_STATICTIMELEFT ), WM_SETTEXT, 0, (long)temp );
SendMessage( GetDlgItem( hwndDlg, IDC_BUTTONCANCEL ), WM_PAINT, 0, 0 );
}
}
break;
case WM_DESTROY:
bCancelCalculation = true;
break;
case WM_COMMAND:
{
switch( LOWORD(wParam) )
{
// ---
case IDC_BUTTONCANCEL:
if( HIWORD(wParam) == BN_CLICKED )
bCancelCalculation = true;
break;
default:
break;
}
}
break;
default:
return FALSE;
break;
}
return TRUE;
}
// -----------------------------------------------------------------------------------------------
void AddLightInfo( CMesh::CMeshBuild *pMB, string &LightName, uint8 nMatNb, uint8 nStageNb )
{
CMesh::CMatStage ms;
ms.nMatNb = nMatNb;
ms.nStageNb = nStageNb;
CMesh::CLightInfoMapList listTemp;
//list< pair< uint8, uint8 > > listTemp;
CMesh::TLightInfoMap::iterator itMap = pMB->LightInfoMap.find( LightName );
if( itMap == pMB->LightInfoMap.end() )
{
listTemp.push_back( ms );
pMB->LightInfoMap.insert( pair< string, CMesh::CLightInfoMapList >(LightName, listTemp) );
}
else
{
itMap->second.push_back( ms );
}
}
// -----------------------------------------------------------------------------------------------
bool isAllBlack( SLMPlane &Plane, uint8 nLayerNb )
{
for( sint32 i = 0; i < Plane.w*Plane.h; ++i )
if( (Plane.col[i].p[nLayerNb].R > 0.06f) || // around 15/255
(Plane.col[i].p[nLayerNb].G > 0.06f) ||
(Plane.col[i].p[nLayerNb].B > 0.06f) )
return false; // Not all is black
return true;
}
// -----------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------
void CNelExport::deleteLM(INode& ZeNode)
{
sint32 i;
// Suppress all lightmap files
for( i = 0; i < 8; ++i )
{
string sSaveName;
sSaveName = theExportSceneStruct.sExportLighting;
if( sSaveName[sSaveName.size()-1] != '\\' ) sSaveName += "\\";
sSaveName += ZeNode.GetName();
char tmp[32];
sprintf( tmp, "%d", i );
sSaveName += tmp;
sSaveName += ".tga";
FILE *file;
if( file = fopen(sSaveName.c_str(),"rb") )
{
fclose( file );
DeleteFile( sSaveName.c_str() );
}
}
}
//bool CNelExport::exportMeshLM(const char *sPath, INode& ZeNode, Interface& ip, TimeValue tvTime)
bool CNelExport::calculateLM(CMesh::CMeshBuild *pZeMeshBuild, INode& ZeNode, Interface& ip, TimeValue tvTime, bool absolutePath)
{
// 1 -> Build all MeshBuild structure
// ----------------------------------
//vector< pair < CMesh::CMeshBuild*,INode* > > AllMeshBuilds;
int nNbMesh = 0;
int i, j;
/*
if( RPO::isZone( ZeNode, tvTime ) )
return false;
if( ! CExportNel::isMesh( ZeNode, tvTime ) )
return false;
pZeMeshBuild = CExportNel::createMeshBuild( ZeNode, tvTime );
*/
// 2 -> LightMapping V2
// --------------------
SWorldRT WorldRT; // The static world for raytrace
vector<SLightBuild> AllLights;
// Select meshes to test for raytrace
// Get all lights from MAX
getLightBuilds( AllLights, tvTime, *theCNelExport.ip );
// Get all lights L that have influence over the mesh selected
// supprLightNoInteract( AllLights, AllMeshBuilds );
supprLightNoInteractOne( AllLights, pZeMeshBuild );
// Get all meshes that are influenced by the lights L
buildWorldRT( WorldRT, AllLights );
//for( nNode=0; nNode < nNbMesh; ++nNode )
{
// First order face by Material and by texture surface
CMesh::CMeshBuild *pMB = pZeMeshBuild;
vector<CMesh::CFace*> AllFaces;
CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
vector<CVector> AllVertices; // All vertices in world space
vector<sint32> FaceGroupByMat; // Number of faces with the same properties
sint32 nNbFace = pMB->Faces.size(), nNbVertex = pMB->Vertices.size();
sint32 offsetMat, offsetSmooth, offsetPlane;
vector<SLMPlane*> AllPlanes;
sint32 AllPlanesPrevSize;
vector< vector<sint32> > vvLights;
// Select Lights interacting with the node
getLightInteract( pMB, AllLights, vvLights );
// Construct the raytrace accelerator from those lights
buildWorldRTAccel( WorldRT, pMB, vvLights );
//gRatioCalculated = ((float)nNode) / ((float)nNbMesh);
//for( i = 0; i < 32; ++i )
//{
// MSG msg;
// PeekMessage(&msg,(HWND)hwndCalculating,0,0,PM_REMOVE);
// {
// if( IsDialogMessage(hwndCalculating,&msg) )
// {
// TranslateMessage(&msg);
// DispatchMessage(&msg);
// }
// }
//}
AllPlanes.clear();
// Make Geometry like we want
// Make a vector of pointer to all the faces of the MeshBuild
AllFaces.resize( nNbFace );
for( i = 0; i < nNbFace; ++i )
AllFaces[i] = &pMB->Faces[i];
// Make All vertices of the mesh in the world basis
AllVertices.resize(nNbVertex);
for( i = 0; i < nNbVertex; ++i )
AllVertices[i] = MBMatrix * pMB->Vertices[i];
// Invert and transpose for use of futur normal
MBMatrix.invert();
MBMatrix.transpose();
// Bubble sort pointer to the faces (Material sorting)
SortFaceByMaterialId( FaceGroupByMat, AllFaces.begin(), AllFaces.size() );
if( ! IsAllFaceMapped( AllFaces.begin(), AllFaces.size() ) )
{
string thetext;
//thetext = "Object ";
thetext += ZeNode.GetName();
thetext = "have not all this faces mapped";
MessageBox( NULL, thetext.c_str(), "Warning", MB_OK|MB_ICONERROR );
return false;
}
// PATCH
FaceGroupByMat.resize(1);
FaceGroupByMat[0] = AllFaces.size();
offsetMat = 0;
for( uint32 nMat = 0; nMat < FaceGroupByMat.size(); ++nMat )
{
vector<sint32> FaceGroupBySmooth;
// Sort faces by smoothing group
SortFaceBySMoothGroup( FaceGroupBySmooth, AllFaces.begin()+offsetMat, FaceGroupByMat[nMat] );
offsetSmooth = offsetMat;
for( uint32 nSmoothNb = 0; nSmoothNb < FaceGroupBySmooth.size(); ++nSmoothNb )
{
uint32 nPlaneNb, nLight;
vector<sint32> FaceGroupByPlane;
if( ! PutFaceUV1InLumelCoord( theExportSceneStruct.rLumelSize, AllVertices,
AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] ) )
continue;
SortFaceByPlane( FaceGroupByPlane, AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] );
//AllPlanes.resize( FaceGroupByPlane.size() );
//SortPlanesBySurface( FaceGroupByPlane, AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] );
AllPlanesPrevSize = AllPlanes.size();
AllPlanes.resize( AllPlanesPrevSize + FaceGroupByPlane.size() );
offsetPlane = offsetSmooth;
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
{
AllPlanes[AllPlanesPrevSize+nPlaneNb] = new SLMPlane;
AllPlanes[AllPlanesPrevSize+nPlaneNb]->nNbLayerUsed = vvLights.size();
// Fill planes (part of lightmap)
CreateLMPlaneFromFaceGroup( *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllFaces.begin()+offsetPlane, FaceGroupByPlane[nPlaneNb] );
// Next group of face with the same plane in the same smooth group of the same material
offsetPlane += FaceGroupByPlane[nPlaneNb];
}
// Make join between all planes (all planes must be created)
for( nLight = 0; nLight < vvLights.size(); ++nLight )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
{
// Light the LightMap for the plane (interior only)
FirstLight( pMB, *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
SecondLight( pMB, AllPlanes.begin()+AllPlanesPrevSize, FaceGroupByPlane.size(),
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
if( theExportSceneStruct.nOverSampling > 1 )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
ModifyLMPlaneWithOverSampling( AllPlanes[AllPlanesPrevSize+nPlaneNb],
theExportSceneStruct.nOverSampling );
for( nLight = 0; nLight < vvLights.size(); ++nLight )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
FirstLight( pMB, *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
SecondLight( pMB, AllPlanes.begin()+AllPlanesPrevSize, FaceGroupByPlane.size(),
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
ModifyLMPlaneWithOverSampling( AllPlanes[AllPlanesPrevSize+nPlaneNb],
1.0/((double)theExportSceneStruct.nOverSampling) );
}
// Next group of face with the same smooth group and the same material
offsetSmooth += FaceGroupBySmooth[nSmoothNb];
}
// Next group of face with the same material
offsetMat += FaceGroupByMat[nMat];
}
// Create the lightmap
SLMPlane LightMap;
SortPlanesBySurface( AllPlanes );
for( i = 0; i < AllPlanes.size(); ++i )
{
// Put in the basis of the plane
MoveFaceUV1( AllPlanes[i]->faces.begin(), AllPlanes[i]->faces.size(),
-AllPlanes[i]->x, -AllPlanes[i]->y );
PlaceLMPlaneInLMPLane( LightMap, *AllPlanes[i] );
LightMap.nNbLayerUsed = AllPlanes[i]->nNbLayerUsed;
// Put in the new basis
MoveFaceUV1( AllPlanes[i]->faces.begin(), AllPlanes[i]->faces.size(),
AllPlanes[i]->x, AllPlanes[i]->y );
delete AllPlanes[i];
}
// Save the lightmap
// Assign the name of the lightmap and get the complete save name
// Update UV coords to Texture space
PutFaceUV1InTextureCoord( LightMap.w, LightMap.h, AllFaces.begin(), nNbFace );
sint32 nLightMapNb = 0;
for( j = 0; j < LightMap.nNbLayerUsed; ++j )
if( ! isAllBlack( LightMap, j ) )
{
CTextureFile *pLightMap = new CTextureFile();
//string sSaveName = AllMeshBuilds[nNode].second->GetName();
string sSaveName = ZeNode.GetName();
char tmp[32];
sprintf( tmp, "%d", nLightMapNb );
sSaveName += tmp;
sSaveName += ".tga";
pLightMap->setFileName( sSaveName );
sSaveName = theExportSceneStruct.sExportLighting;
if( sSaveName[sSaveName.size()-1] != '\\' ) sSaveName += "\\";
sSaveName += pLightMap->getFileName();
CopyPlaneColToBitmap32( pLightMap, LightMap, j );
COFile f( sSaveName );
pLightMap->writeTGA( f, 32 );
for( i = 0; i < pMB->Materials.size(); ++i )
{
pMB->Materials[i].setLightMap( nLightMapNb, pLightMap );
//AllMeshBuilds[nNode].first->Materials[i].setLighting( false );
AddLightInfo( pMB, AllLights[vvLights[j].operator[](0)].GroupName, i, nLightMapNb );
int a = pMB->LightInfoMap.size();
}
++nLightMapNb;
}
// Next mesh
//if( bCancelCalculation )
// break;
}
for( i = 0; i < WorldRT.vMB.size(); ++i )
delete WorldRT.vMB[i];
// End of the lighting process for this node we have to export the data
//for( nNode=0; nNode < nNbMesh; ++nNode )
{
// First order face by Material and by texture surface
//CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
CMesh::CMeshBuild *pMB = pZeMeshBuild;
CMesh* mesh = new CMesh;
pMB->VertexFlags |= CVertexBuffer::TexCoord1Flag;
// Build the mesh with the build interface
for( i = 0; i < pMB->Materials.size(); ++i )
{
pMB->Materials[i].setLighting( false );
pMB->Materials[i].setColor( CRGBA(255,255,255,255) );
}
/*
mesh->build( *pMB );
COFile file;
if (file.open( sPath ))
{
try
{
// Create a streamable shape
CShapeStream shapeStream( mesh );
// Serial the shape
shapeStream.serial (file);
}
catch (...)
{
}
}
// Delete the pointer
delete mesh;
*/
}
// Delete the window
//DestroyWindow( hwndCalculating );
// ? -> Ending deletion des objets temporaires
//for( nNode = 0; nNode < nNbMesh; ++nNode )
// delete AllMeshBuilds[nNode].first;
//delete pZeMeshBuild;
return true;
}
bool CNelExport::exportScene(std::vector<INode*>& vectNode)
{
// All inputs are transfered throught the global theExportSceneStruct structure
// Export the Instance Group (aka scene description)
// *************************
if( theExportSceneStruct.bExportInstanceGroup )
exportInstanceGroup( theExportSceneStruct.sExportInstanceGroup, vectNode );
// Export all the shapes
// *********************
// If lighting enabled we export the shape after lightmapping modification
if( theExportSceneStruct.bExportShapes && (!theExportSceneStruct.bExportLighting) )
{
// Get time
TimeValue tvTime = theCNelExport.ip->GetTime();
// Get node count
int nNumSelNode = vectNode.size();
// Save all selected objects
for (int nNode=0; nNode<nNumSelNode; nNode++)
{
// Get the node
INode* pNode=vectNode[nNode];
// It is a zone ?
if (RPO::isZone (*pNode, tvTime))
{
// Nothing to do if this is a zone
}
// Try to export a mesh
else if (CExportNel::isMesh (*pNode, tvTime))
{
// Build the name of the file to export
char sSavePath[512];
strcpy( sSavePath, theExportSceneStruct.sExportShapes.c_str() );
if(theExportSceneStruct.sExportShapes[theExportSceneStruct.sExportShapes.size()-1] != '\\' )
strcat( sSavePath, "\\" );
strcat( sSavePath, pNode->GetName() );
strcat( sSavePath, ".shape" );
// Export the mesh
if (!theCNelExport.exportMesh (sSavePath, *pNode, *theCNelExport.ip, tvTime))
{
// Error message
char sErrorMsg[512];
sprintf (sErrorMsg, "Error exporting the mesh %s in the file\n%s", pNode->GetName(), sSavePath);
MessageBox (theCNelExport.ip->GetMAXHWnd(), sErrorMsg, "NeL export scene", MB_OK|MB_ICONEXCLAMATION );
}
}
}
}
// Export the lighting (aka compute all light maps)
// *******************
if( theExportSceneStruct.bExportLighting )
{
TTicks zeTime = CTime::getPerformanceTime();
// 1 -> Build all MeshBuild structure
// ----------------------------------
vector< pair < CMesh::CMeshBuild*,INode* > > AllMeshBuilds;
TimeValue tvTime = theCNelExport.ip->GetTime();
int nNumSelNode = vectNode.size();
int nNbMesh = 0;
int nNode, i, j;
// Launch the dialog box
bCancelCalculation = true;
HWND hwndCalculating = CreateDialog( CNelExportDesc.HInstance(),
MAKEINTRESOURCE(IDD_CALCULATING),
theCNelExport.ip->GetMAXHWnd(),
CalculatingDialogCallback );
// Count number of mesh in the selection
for( nNode = 0; nNode < nNumSelNode; ++nNode )
{
INode* pNode = vectNode[nNode];
if( ! RPO::isZone( *pNode, tvTime ) )
if( CExportNel::isMesh( *pNode, tvTime ) )
nNbMesh++;
}
AllMeshBuilds.resize(nNbMesh);
nNbMesh = 0;
// Create all the MeshBuild used to place lightmaps and to raytrace lightmaps
for( nNode=0; nNode < nNumSelNode; ++nNode )
{
INode* pNode = vectNode[nNode];
if( ! RPO::isZone( *pNode, tvTime ) )
if( CExportNel::isMesh( *pNode, tvTime ) )
{
AllMeshBuilds[nNbMesh].second = pNode;
AllMeshBuilds[nNbMesh].first = CExportNel::createMeshBuild( *pNode, tvTime );
nNbMesh++;
}
}
// Suppress all lightmap files
for( nNode=0; nNode < nNbMesh; ++nNode )
for( i = 0; i < 8; ++i )
{
string sSaveName;
sSaveName = theExportSceneStruct.sExportLighting;
if( sSaveName[sSaveName.size()-1] != '\\' ) sSaveName += "\\";
sSaveName += AllMeshBuilds[nNode].second->GetName();
char tmp[32];
sprintf( tmp, "%d", i );
sSaveName += tmp;
sSaveName += ".tga";
FILE *file;
if( file = fopen(sSaveName.c_str(),"rb") )
{
fclose( file );
DeleteFile( sSaveName.c_str() );
}
}
// 2 -> LightMapping V2
// --------------------
SWorldRT WorldRT; // The static world for raytrace
// vector< pair < CMesh::CMeshBuild*, CBSphere > > MeshBuildForRaytrace;
vector<SLightBuild> AllLights;
// Select meshes to test for raytrace
// Get all lights from MAX
getLightBuilds( AllLights, tvTime, *theCNelExport.ip );
// Get all lights L that have influence over the mesh selected
supprLightNoInteract( AllLights, AllMeshBuilds );
// Get all meshes that are influenced by the lights L
buildWorldRT( WorldRT, AllLights );
for( nNode=0; nNode < nNbMesh; ++nNode )
{
// First order face by Material and by texture surface
CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
vector<CMesh::CFace*> AllFaces;
CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
vector<CVector> AllVertices; // All vertices in world space
vector<sint32> FaceGroupByMat; // Number of faces with the same properties
sint32 nNbFace = pMB->Faces.size(), nNbVertex = pMB->Vertices.size();
sint32 offsetMat, offsetSmooth, offsetPlane;
vector<SLMPlane*> AllPlanes;
sint32 AllPlanesPrevSize;
vector< vector<sint32> > vvLights;
TTicks zeTime2 = CTime::getPerformanceTime();
// Select Lights interacting with the node
getLightInteract( pMB, AllLights, vvLights );
// Construct the raytrace accelerator from those lights
buildWorldRTAccel( WorldRT, pMB, vvLights );
gRatioCalculated = ((float)nNode) / ((float)nNbMesh);
for( i = 0; i < 32; ++i )
{
MSG msg;
PeekMessage(&msg,(HWND)hwndCalculating,0,0,PM_REMOVE);
{
if( IsDialogMessage(hwndCalculating,&msg) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
AllPlanes.clear();
// Make Geometry like we want
// Make a vector of pointer to all the faces of the MeshBuild
AllFaces.resize( nNbFace );
for( i = 0; i < nNbFace; ++i )
AllFaces[i] = &pMB->Faces[i];
// Make All vertices of the mesh in the world basis
AllVertices.resize(nNbVertex);
for( i = 0; i < nNbVertex; ++i )
AllVertices[i] = MBMatrix * pMB->Vertices[i];
// Invert and transpose for use of futur normal
MBMatrix.invert();
MBMatrix.transpose();
// Bubble sort pointer to the faces (Material sorting)
SortFaceByMaterialId( FaceGroupByMat, AllFaces.begin(), AllFaces.size() );
if( ! IsAllFaceMapped( AllFaces.begin(), AllFaces.size() ) )
{
string thetext;
//thetext = "Object ";
//thetext += AllMeshBuilds[nNode].second->GetName();
//thetext = "have not all this faces mapped";
//MessageBox( NULL, thetext.c_str(), "Warning", MB_OK );
continue;
}
// PATCH
FaceGroupByMat.resize(1);
FaceGroupByMat[0] = AllFaces.size();
timerInit += CTime::getPerformanceTime() - zeTime2;
zeTime2 = CTime::getPerformanceTime();
offsetMat = 0;
for( uint32 nMat = 0; nMat < FaceGroupByMat.size(); ++nMat )
{
vector<sint32> FaceGroupBySmooth;
// Sort faces by smoothing group
SortFaceBySMoothGroup( FaceGroupBySmooth, AllFaces.begin()+offsetMat, FaceGroupByMat[nMat] );
offsetSmooth = offsetMat;
for( uint32 nSmoothNb = 0; nSmoothNb < FaceGroupBySmooth.size(); ++nSmoothNb )
{
uint32 nPlaneNb, nLight;
vector<sint32> FaceGroupByPlane;
if( ! PutFaceUV1InLumelCoord( theExportSceneStruct.rLumelSize, AllVertices,
AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] ) )
continue;
SortFaceByPlane( FaceGroupByPlane, AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] );
//AllPlanes.resize( FaceGroupByPlane.size() );
//SortPlanesBySurface( FaceGroupByPlane, AllFaces.begin()+offsetSmooth, FaceGroupBySmooth[nSmoothNb] );
AllPlanesPrevSize = AllPlanes.size();
AllPlanes.resize( AllPlanesPrevSize + FaceGroupByPlane.size() );
offsetPlane = offsetSmooth;
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
{
AllPlanes[AllPlanesPrevSize+nPlaneNb] = new SLMPlane;
AllPlanes[AllPlanesPrevSize+nPlaneNb]->nNbLayerUsed = vvLights.size();
// Fill planes (part of lightmap)
CreateLMPlaneFromFaceGroup( *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllFaces.begin()+offsetPlane, FaceGroupByPlane[nPlaneNb] );
// Next group of face with the same plane in the same smooth group of the same material
offsetPlane += FaceGroupByPlane[nPlaneNb];
}
// Make join between all planes (all planes must be created)
for( nLight = 0; nLight < vvLights.size(); ++nLight )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
{
// Light the LightMap for the plane (interior only)
FirstLight( pMB, *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
SecondLight( pMB, AllPlanes.begin()+AllPlanesPrevSize, FaceGroupByPlane.size(),
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
if( theExportSceneStruct.nOverSampling > 1 )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
ModifyLMPlaneWithOverSampling( AllPlanes[AllPlanesPrevSize+nPlaneNb],
theExportSceneStruct.nOverSampling );
for( nLight = 0; nLight < vvLights.size(); ++nLight )
{
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
FirstLight( pMB, *AllPlanes[AllPlanesPrevSize+nPlaneNb],
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
SecondLight( pMB, AllPlanes.begin()+AllPlanesPrevSize, FaceGroupByPlane.size(),
AllVertices, MBMatrix, vvLights[nLight], AllLights,
nLight, WorldRT );
}
for( nPlaneNb = 0; nPlaneNb < FaceGroupByPlane.size(); ++nPlaneNb )
ModifyLMPlaneWithOverSampling( AllPlanes[AllPlanesPrevSize+nPlaneNb],
1.0/((double)theExportSceneStruct.nOverSampling) );
}
// Next group of face with the same smooth group and the same material
offsetSmooth += FaceGroupBySmooth[nSmoothNb];
}
// Next group of face with the same material
offsetMat += FaceGroupByMat[nMat];
}
timerCalc += CTime::getPerformanceTime() - zeTime2;
// Create the lightmap
zeTime2 = CTime::getPerformanceTime();
SLMPlane LightMap;
SortPlanesBySurface( AllPlanes );
for( i = 0; i < AllPlanes.size(); ++i )
{
// Put in the basis of the plane
MoveFaceUV1( AllPlanes[i]->faces.begin(), AllPlanes[i]->faces.size(),
-AllPlanes[i]->x, -AllPlanes[i]->y );
PlaceLMPlaneInLMPLane( LightMap, *AllPlanes[i] );
LightMap.nNbLayerUsed = AllPlanes[i]->nNbLayerUsed;
// Put in the new basis
MoveFaceUV1( AllPlanes[i]->faces.begin(), AllPlanes[i]->faces.size(),
AllPlanes[i]->x, AllPlanes[i]->y );
delete AllPlanes[i];
}
timerPlac += CTime::getPerformanceTime() - zeTime2;
// Save the lightmap
// Assign the name of the lightmap and get the complete save name
zeTime2 = CTime::getPerformanceTime();
// Update UV coords to Texture space
PutFaceUV1InTextureCoord( LightMap.w, LightMap.h, AllFaces.begin(), nNbFace );
sint32 nLightMapNb = 0;
for( j = 0; j < LightMap.nNbLayerUsed; ++j )
if( ! isAllBlack( LightMap, j ) )
{
CTextureFile *pLightMap = new CTextureFile();
string sSaveName = AllMeshBuilds[nNode].second->GetName();
char tmp[32];
sprintf( tmp, "%d", nLightMapNb );
sSaveName += tmp;
sSaveName += ".tga";
pLightMap->setFileName( sSaveName );
sSaveName = theExportSceneStruct.sExportLighting;
if( sSaveName[sSaveName.size()-1] != '\\' ) sSaveName += "\\";
sSaveName += pLightMap->getFileName();
CopyPlaneColToBitmap32( pLightMap, LightMap, j );
COFile f( sSaveName );
pLightMap->writeTGA( f, 32 );
for( i = 0; i < pMB->Materials.size(); ++i )
{
pMB->Materials[i].setLightMap( nLightMapNb, pLightMap );
//AllMeshBuilds[nNode].first->Materials[i].setLighting( false );
AddLightInfo( pMB, AllLights[vvLights[j].operator[](0)].GroupName, i, nLightMapNb );
int a = pMB->LightInfoMap.size();
}
++nLightMapNb;
}
timerSave += CTime::getPerformanceTime() - zeTime2;
// Next mesh
//delete pLightMap; // TODO vector<> de lightmap
if( bCancelCalculation )
break;
}
for( i = 0; i < WorldRT.vMB.size(); ++i )
delete WorldRT.vMB[i];
// End of the lighting process for this node we have to export the data
for( nNode=0; nNode < nNbMesh; ++nNode )
{
// First order face by Material and by texture surface
CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
CMesh* mesh = new CMesh;
pMB->VertexFlags |= CVertexBuffer::TexCoord1Flag;
// Build the mesh with the build interface
for( i = 0; i < pMB->Materials.size(); ++i )
{
pMB->Materials[i].setLighting( false );
pMB->Materials[i].setColor( CRGBA(255,255,255,255) );
}
mesh->build( *pMB );
COFile file;
char sSavePath[512];
strcpy( sSavePath, theExportSceneStruct.sExportShapes.c_str() );
if(theExportSceneStruct.sExportShapes[theExportSceneStruct.sExportShapes.size()-1] != '\\' )
strcat( sSavePath, "\\" );
strcat( sSavePath, AllMeshBuilds[nNode].second->GetName() );
strcat( sSavePath, ".shape" );
if (file.open( sSavePath ))
{
try
{
// Create a streamable shape
CShapeStream shapeStream( mesh );
// Serial the shape
shapeStream.serial (file);
}
catch (...)
{
}
}
// Delete the pointer
delete mesh;
}
// Delete the window
DestroyWindow( hwndCalculating );
// ? -> Ending deletion des objets temporaires
for( nNode = 0; nNode < nNbMesh; ++nNode )
delete AllMeshBuilds[nNode].first;
timerExportLighting = CTime::getPerformanceTime() - zeTime;
{
string toDisp;
char tam[1024];
sprintf( tam, "timerExport = %f sec\n", (float)CTime::ticksToSecond( timerExportLighting ) );
toDisp += tam;
sprintf( tam, "timerInit = %f %%\n", 100*((float)timerInit)/((float)timerExportLighting) );
toDisp += tam;
sprintf( tam, "timerCalc = %f %%\n", 100*((float)timerCalc)/((float)timerExportLighting) );
toDisp += tam;
sprintf( tam, " timerCalcRT = %f %%\n", 100*((float)timerCalcRT)/((float)timerExportLighting) );
toDisp += tam;
sprintf( tam, "timerPlac = %f %%\n", 100*((float)timerPlac)/((float)timerExportLighting) );
toDisp += tam;
sprintf( tam, "timerSave = %f %%\n", 100*((float)timerSave)/((float)timerExportLighting) );
toDisp += tam;
MessageBox( theCNelExport.ip->GetMAXHWnd(), toDisp.c_str(), "Info", MB_OK );
}
} // End if lighting process asked
return true;
}
Reference in a new issue View git blame Copy permalink