aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-15 22:08:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/zone_lighter.cpp

3865 lines
111 KiB
C++
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
// FIXME: shouldn't this be configured outside?
#ifndef USE_JPEG
#define USE_JPEG
#endif
#include "nel/3d/zone_lighter.h"
#include "nel/3d/landscape.h"
#include "nel/3d/patchuv_locator.h"
#include "nel/3d/shape.h"
#include "nel/3d/mesh.h"
#include "nel/3d/mesh_multi_lod.h"
#include "nel/3d/mesh_mrm.h"
#include "nel/3d/transform_shape.h"
#include "nel/3d/water_shape.h"
#include "nel/3d/texture_file.h"
#include "nel/misc/common.h"
#include "nel/misc/thread.h"
#include "nel/misc/path.h"
#include "nel/misc/file.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/algo.h"
#ifdef NL_OS_WINDOWS
# define WIN32_LEAN_AND_MEAN
# define NOMINMAX
# include <windows.h>
# include <winbase.h>
#endif // NL_OS_WINDOWS
using namespace NLMISC;
using namespace NL3D;
using namespace std;
// Define this to render the zbuffers into a bitmap zbuffer and save it into a jpeg
// #define SAVE_ZBUFFER "c:/temp"
#define DEFAULT_JITTER 0.4f
#define DEFAULT_ZBUFFER_LANDSCAPE_SIZE 32768
#define DEFAULT_ZBUFFER_OBJECT_SIZE (32768*3)
#define DEFAULT_SUN_DISTANCE 50000
#define DEFAULT_SUN_FOV (NLMISC::Pi/6)
#define DEFAULT_SUN_CENTER (CVector (0, 0, 0))
#define DEFAULT_SUN_RADIUS 5000
#define DEFAULT_SUN_SRQT_SAMPLES 4
// Bad coded: don't set too big else it allocates too much memory.
#define NL3D_ZONE_LIGHTER_CUBE_GRID_SIZE 16
// ***************************************************************************
/*
Documentation:
To light a zone, you must first adding shadow caster triangles using the addTriangle() methods.
Triangles can come from landscape zones or IG meshes. Then call the lighting process with ligth().
addTriangle ()
- Add landscape triangles to shadow caster triangle list
- Tesselate the landscape to shadow accuracy (2 meters)
- Add others triangles to shadow caster triangle list (trees, building)
- AlphaTest textures can be used here
light ()
The lighting process uses a software zbuffers render to compute shadow attenuation of the zone.
CRenderZBuffer () (multithread)
- Render shadow caster triangles into the light zbuffers for shadows. Each z value is tested and
written in the pixel and in the 8 neighbor pixels.
- There is a zbuffer per landscape softshadow sample and an additionnal zbuffer for objects. So
landscape triangles cast softshadows and object (trees and building) cast antialiased shadows.
- Render shadow caster triangles into a heightfield used for radiosity
buildZoneInformation ()
- Tesselate the landscape to shadow accuracy (2 meters)
- Compute lumel positions.
Lumel position is the average of lumel triangles center overlapping
the lumel but using the shadow accuracy triangle position because
we need the same triangles than shadow caster polygons.
Border lumel position are extended to fit the patch border.
- Tesselate to lumel accuracy (0.5 meter)
- Compute lumel normal
- Lumel normal is the average of lumel triangles normals. The normals
comes from the lumel accuracy to get more precise lighting. So normals
are interpolated from the center of the lumel but they will be rendered
on the patch border. Unlike the position, we can extand the normal to the
border without loosing normal precision because normal interpolation is
aligned with the tesselation. So we need some border normal smoothing.
- Border normal smoothing
- Normals on the border of the patches are smoothed with neighbor normals.
CLightRunnable () (multithread)
- For each patches and for each lumels
attenuation ()
- Compute shadow attenuation
- Get an antialised attenuation value in each lansdcape softshadow zbuffer.
Average it with jitter.
- Get an antialised attenuation value from the object zbuffer.
- Return the smaller value of the both.
- Compute sun lighting (dot product)
getSkyContribution ()
- Compute sky lighting (radiosity)
- Algorithm
- Get the lumel position in the heightfield
- Lookup in the 8 2d directions for max height
- Compute an approximation of the sky surface visible from
the lumel position
- Store final lumel luminosity
*/
// ***************************************************************************
inline float easineasout(float x)
{
float y;
// cubic tq f(0)=0, f'(0)=0, f(1)=1, f'(1)=0.
float x2=x*x;
float x3=x2*x;
y= -2*x3 + 3*x2;
return y;
}
// ***************************************************************************
inline void transformVectorToZBuffer (const CZoneLighter::CZBuffer& zbuffer, const CVector &world, CVector &projected)
{
projected = zbuffer.WorldToZBuffer * world;
float temp = projected.z;
projected.z = projected.y;
projected.y = -temp;
projected = zbuffer.WorldToZBufferFrustum.project (projected);
// Scale to zbuffer size
projected.x *= zbuffer.ZBufferPixelSize;
projected.y *= zbuffer.ZBufferPixelSize;
projected.z = temp;
}
// ***********************************************************
static const sint DeltaZ[9][2]=
{
{0, 0},
{-1, 0},
{1, 0},
{0, -1},
{0, 1},
{-1, -1},
{1, 1},
{1, -1},
{-1, 1},
};
// ***************************************************************************
inline float testZPercentageCloserFilter (float x, float y, float z, CZoneLighter::CZBuffer &zbuffer, const CZoneLighter::CLightDesc &description, bool &zBufferOverflowFlag)
{
// See "Rendering Antialiased Shadows With Depth Maps" Reeves, Salesint, Cook, ACM 1987
// Bilinear filtering
float biliValues[2][2];
float ix = (float)floor (x-0.5f);
float factorX = x - (ix+0.5f);
nlassert (factorX>=0);
nlassert (factorX<=1);
float iy = (float)floor (y-0.5f);
float factorY = y - (iy+0.5f);
nlassert (factorY>=0);
nlassert (factorY<=1);
sint dx, dy;
for (dy=0; dy<2; dy++)
for (dx=0; dx<2; dx++)
{
const sint fx = dx + (sint)ix;
const sint fy = dy + (sint)iy;
if ((fx >= 0) && (fx < zbuffer.LocalZBufferWidth) && (fy >= 0) && (fy < zbuffer.LocalZBufferHeight))
{
const float zRed = zbuffer.Pixels[fx + (zbuffer.LocalZBufferHeight - 1 - fy) * zbuffer.LocalZBufferWidth];
biliValues[dx][dy] = (zRed < (-z)) ? 0.f : 1.f;
}
else
{
biliValues[dx][dy] = 1;
zBufferOverflowFlag = true;
}
}
// Bilinear
return (biliValues[0][0] * (1 - factorX) + biliValues[1][0] * factorX) * (1 - factorY) +
(biliValues[0][1] * (1 - factorX) + biliValues[1][1] * factorX) * factorY;
}
// ***************************************************************************
CZoneLighter::CZoneLighter () : _PatchComputed ("PatchComputed")
{
}
// ***************************************************************************
void CZoneLighter::init ()
{
// Precalc some values
for (uint i=0; i<8; i++)
{
// Precalc sinP and cosP
float sinP=(float)(sin((Pi/4)*(i+0.5))-sin((Pi/4)*(i-0.5)));
float cosP=(float)(cos((Pi/4)*(i-0.5))-cos((Pi/4)*(i+0.5)));
for (uint phi=0; phi<256; phi++)
{
// Real phi
float fPhi=(float)((Pi/2)*phi/256.0);
// Tmp result
float tmp0=(float)(fPhi-sin(2*fPhi)/2);
float tmp1=(float)sin(fPhi);
// Calc K
_K[phi][i].set (tmp0*sinP, tmp0*cosP, (float)((Pi/4)*tmp1*tmp1));
}
}
// Init some containers
_ZBufferOverflow = false;
_Bitmaps.clear ();
}
// ***************************************************************************
// N - NW - W - SW - S - SE - E - NE
static const sint deltaDirection[8][2]=
{
{1, 0},
{1, 1},
{0, 1},
{-1, 1},
{-1, 0},
{-1, -1},
{0, -1},
{1, -1},
};
// ***************************************************************************
float CZoneLighter::calcSkyContribution (sint s, sint t, float height, float skyIntensity, const CVector& normal) const
{
// Sky contribution
float skyContribution;
// Calc k
CVector k (0, 0, 0);
// For the height direction
for (uint i=0; i<8; i++)
{
// Get phi for this point
uint8 phi=getMaxPhi (s, t, deltaDirection[i][0], deltaDirection[i][1], height);
// Add to k
k+=_K[phi][i];
}
// Finalize sky contribution
skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi));
skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi));
clamp (skyContribution, 0.f, 1.f);
return skyContribution;
}
// ***************************************************************************
void NEL3DCalcBase (CVector &direction, CMatrix& matrix)
{
direction.normalize();
CVector K=-direction;
CVector I=CVector::K^K;
CVector J=K^I;
J.normalize();
I=J^K;
I.normalize();
matrix.identity();
matrix.setRot(I,J,K, true);
}
// ***************************************************************************
void setCPUMask (IThread *thread, uint process)
{
// Set the processor mask
uint64 mask = IProcess::getCurrentProcess()->getCPUMask ();
// Mask must not be NULL
nlassert (mask != 0);
if (mask != 0)
{
uint i=0;
uint count = 0;
for(;;)
{
if (mask & (UINT64_CONSTANT(1)<<i))
{
if (count == process)
break;
count++;
}
i++;
if (i==64)
i = 0;
}
// Set the CPU mask
thread->setCPUMask (1<<i);
}
}
// ***************************************************************************
class NL3D::CLightRunnable : public IRunnable
{
// Members
uint _Process;
CZoneLighter *_ZoneLighter;
const CZoneLighter::CLightDesc *_Description;
public:
IThread *Thread;
public:
// Ctor
CLightRunnable (uint process, CZoneLighter *zoneLighter, const CZoneLighter::CLightDesc *description)
{
_ZoneLighter = zoneLighter;
_Process = process;
_Description = description;
}
// Run method
void run()
{
// Set the CPU mask
setCPUMask (Thread, _Process);
_ZoneLighter->processCalc (_Process, *_Description);
_ZoneLighter->_ProcessExited++;
}
};
// ***************************************************************************
class NL3D::CRenderZBuffer : public IRunnable
{
// Members
uint _Process;
CZoneLighter *_ZoneLighter;
// The lighting decription
const CZoneLighter::CLightDesc *_Description;
// Triangles to render
uint _FirstTriangle;
uint _NumTriangle;
const vector<CZoneLighter::CTriangle> *_Triangles;
public:
IThread *Thread;
public:
// Ctor
CRenderZBuffer (uint process, CZoneLighter *zoneLighter, const CZoneLighter::CLightDesc *description, uint firstTriangle, uint numTriangle, const vector<CZoneLighter::CTriangle> *triangles)
{
_ZoneLighter = zoneLighter;
_Description = description;
_Process = process;
_FirstTriangle = firstTriangle;
_NumTriangle = numTriangle;
_Triangles = triangles;
}
// Run method
virtual void run ();
};
// ***************************************************************************
#define CLIPPED_TOP 1
#define CLIPPED_BOTTOM 2
#define CLIPPED_RIGHT 3
#define CLIPPED_LEFT 4
#define CLIPPED_ALL (CLIPPED_TOP|CLIPPED_BOTTOM|CLIPPED_LEFT|CLIPPED_RIGHT)
void RenderTriangle (const CZoneLighter::CTriangle &triangle, const CZoneLighter::CLightDesc &description, CPolygon2D::TRasterVect &borders,
CFastMutex &mutex, CZoneLighter::CZBuffer &zbuffer, uint radius)
{
// *** Transform it in the zbuffer basis
// 2d polygon used for rasteriation
CPolygon2D zBasis;
zBasis.Vertices.resize (3);
// 3d polygon used for the gradient
NLMISC::CTriangle gradientTriangle;
// One over z value
float ooz[3];
// Clipping
uint8 in = 0;
// For each vertex
for (uint j=0; j<3; j++)
{
// Pointer on the vector
const CVector *pt = (&triangle.Triangle.V0)+j;
CVector *ptDest = (&gradientTriangle.V0)+j;
// Transform it in the zbuffer basis
transformVectorToZBuffer (zbuffer, *pt, *ptDest);
// Clip
if (ptDest->x >= zbuffer.LocalZBufferXMin)
in |= CLIPPED_LEFT;
if (ptDest->x <= zbuffer.LocalZBufferXMax)
in |= CLIPPED_RIGHT;
if (ptDest->y >= zbuffer.LocalZBufferYMin)
in |= CLIPPED_TOP;
if (ptDest->y <= zbuffer.LocalZBufferYMax)
in |= CLIPPED_BOTTOM;
// Set the 2d points
zBasis.Vertices[j].x = ptDest->x - (float)zbuffer.LocalZBufferXMin;
zBasis.Vertices[j].y = ptDest->y - (float)zbuffer.LocalZBufferYMin;
ooz[j] = 1.f / ptDest->z;
// No z
ptDest->z = 0;
}
// Not clipped ?
if (in == CLIPPED_ALL)
{
// Rasterise
sint minimumY;
borders.clear ();
zBasis.computeBorders (borders, minimumY);
// Compute the gradient for one over z
CVector ozzGradient;
gradientTriangle.computeGradient (ooz[0], ooz[1], ooz[2], ozzGradient);
// Need uv ?
bool needUV = triangle.Texture != NULL;
// Compute the gradient for uv
CVector uGradient;
CVector vGradient;
if (needUV)
{
gradientTriangle.computeGradient (triangle.U[0], triangle.U[1], triangle.U[2], uGradient);
gradientTriangle.computeGradient (triangle.V[0], triangle.V[1], triangle.V[2], vGradient);
}
// Texture informations
uint width=0;
uint height=0;
const CObjectVector<uint8> *pixels = 0;
if (needUV)
{
// Get pixels
pixels = &triangle.Texture->getPixels ();
// Get width and height
width = triangle.Texture->getWidth ();
height = triangle.Texture->getHeight ();
}
// For each scanlines
sint y = std::max (minimumY, 0);
sint yMax = std::min ((sint)(minimumY+borders.size ()), zbuffer.LocalZBufferHeight);
for (; y<yMax; y++)
{
// Ref on the raster
const CPolygon2D::TRaster &raster = borders[y-minimumY];
// Gradient y for ooz, u and v
const float deltaY = (float)y - zBasis.Vertices[0].y;
const float oozGradientY = deltaY * ozzGradient.y;
float uGradientY=0.0f;
float vGradientY=0.0f;
if (needUV)
{
uGradientY = deltaY * uGradient.y;
vGradientY = deltaY * vGradient.y;
}
// Clip it
sint x = std::max (raster.first, 0);
sint xMax = std::min (raster.second+1, zbuffer.LocalZBufferWidth);
for (; x<xMax; x++)
{
// Gradient x for ooz, u and v
const float deltaX = (float)x - zBasis.Vertices[0].x;
const float oozGradientX = deltaX * ozzGradient.x;
float uGradientX=0.0f;
float vGradientX=0.0f;
if (needUV)
{
uGradientX = deltaX * uGradient.x;
vGradientX = deltaX * vGradient.x;
}
// Calc z
float z = - 1.f / (ooz[0] + oozGradientX + oozGradientY);
// Calc u & v
float u;
float v;
bool alphaTest = true;
if (needUV)
{
// Compute uv
u = triangle.U[0] + uGradientX + uGradientY;
v = triangle.V[0] + vGradientX + vGradientY;
// Clamp or wrap ?
if (triangle.Flags & CZoneLighter::CTriangle::ClampU)
clamp (u, 0.f, 1.f);
else
u -= (float)floor (u);
if (triangle.Flags & CZoneLighter::CTriangle::ClampV)
clamp (v, 0.f, 1.f);
else
v -= (float)floor (v);
// Lookup in the texture
u *= width;
v *= height;
clamp (u, 0, width-1);
clamp (v, 0, height-1);
uint8 alpha = ((const CRGBA*)&((*pixels)[(((uint)u)+((uint)v)*width)*sizeof (CRGBA)]))->A;
// Alpha test
alphaTest = alpha >= triangle.AlphaTestThreshold;
}
// Good alpha test ?
if (alphaTest)
{
// Enter the mutex
mutex.enter ();
// Write Z around
uint d;
for (d=0; d<radius; d++)
{
// Ref in the zbuffer
sint fx = x + DeltaZ[d][0];
sint fy = y + DeltaZ[d][1];
if ( (fx >= 0) && (fx < zbuffer.LocalZBufferWidth) && (fy >= 0) && (fy < zbuffer.LocalZBufferHeight) )
{
float &zValue = zbuffer.Pixels[fx+(zbuffer.LocalZBufferHeight-fy-1)*zbuffer.LocalZBufferWidth];
// Z test
if (z < zValue)
{
// Render z in zbuffer
zValue = z;
}
}
}
// Leave the mutex
mutex.leave ();
}
}
}
}
}
void NL3D::CRenderZBuffer::run()
{
// Set the CPU mask
setCPUMask (Thread, _Process);
// Span array
CPolygon2D::TRasterVect borders;
// For each triangles
uint i;
for (i=_FirstTriangle; i<_FirstTriangle+_NumTriangle; i++)
{
// Triangle reference
const CZoneLighter::CTriangle &triangle = (*_Triangles)[i];
// Keep backface and doublesided polygons
if ((triangle.Flags & CZoneLighter::CTriangle::DoubleSided) || ((triangle.getPlane ().getNormal() * _ZoneLighter->_SunDirection) > 0))
{
// Landscape triangle ?
if (triangle.Flags & CZoneLighter::CTriangle::Landscape)
{
// For each landscape zbuffer
uint sample;
const uint samples = _Description->SoftShadowSamplesSqrt*_Description->SoftShadowSamplesSqrt;
for (sample=0; sample<samples; sample++)
{
RenderTriangle (triangle, *_Description, borders, _ZoneLighter->_Mutex, _ZoneLighter->_ZBufferLandscape[sample], 9);
}
}
else
{
// Render in a high resolution zbuffer
RenderTriangle (triangle, *_Description, borders, _ZoneLighter->_Mutex, _ZoneLighter->_ZBufferObject, 1);
}
}
_ZoneLighter->_NumberOfPatchComputed++;
}
// Exit
_ZoneLighter->_ProcessExited++;
}
// ***************************************************************************
class NL3D::CCalcLightableShapeRunnable : public IRunnable
{
public:
CCalcLightableShapeRunnable(uint process,
CZoneLighter *zoneLighter,
const CZoneLighter::CLightDesc *description,
CZoneLighter::TShapeVect *shapeToLit,
uint firstShape,
uint lastShape
)
:
_ZoneLighter(zoneLighter),
_Description(description),
_ShapesToLit(shapeToLit),
_FirstShape(firstShape),
_LastShape(lastShape),
_Process(process)
{
}
void run()
{
_ZoneLighter->processLightableShapeCalc(_Process, _ShapesToLit, _FirstShape, _LastShape, *_Description);
_ZoneLighter->_ProcessExited++;
}
private:
CZoneLighter *_ZoneLighter;
const CZoneLighter::CLightDesc *_Description;
CZoneLighter::TShapeVect *_ShapesToLit;
uint _FirstShape, _LastShape;
uint _Process;
};
// ***************************************************************************
void draw2dLine (CBitmap &bitmap, float x0, float y0, float x1, float y1, const CRGBA &color)
{
static vector< std::pair<sint, sint> > lines;
drawFullLine (x0, y0, x1, y1, lines);
// Bitmap pixels
CRGBA *pixels = (CRGBA*)&(bitmap.getPixels ()[0]);
// Bitmap size
sint width = (sint)bitmap.getWidth ();
sint height = (sint)bitmap.getHeight ();
// Draw the line
uint i;
for (i=0; i<lines.size (); i++)
{
sint x = lines[i].first;
sint y = lines[i].second;
// Clip
if ( (x >= 0) && (x < width) && (y >= 0) && (y < height) )
{
pixels[x+(height-y-1)*width] = color;
}
}
}
// ***************************************************************************
void InitZBuffer (CZoneLighter::CZBuffer &zbuffer, const CVector &SunPosition, const CMatrix &rayBasis, const CAABBoxExt &zoneBB, uint zBufferPixelSize, const CZoneLighter::CLightDesc& description)
{
// Clac the zbuffer world size
const float zBufferWorldSize = (float)(tan (description.SunFOV/2)*description.SunDistance*2);
// ** Compute the zbuffer basis
zbuffer.WorldToZBuffer.identity ();
zbuffer.WorldToZBuffer = rayBasis;
zbuffer.WorldToZBuffer.setPos (SunPosition);
zbuffer.WorldToZBuffer.invert ();
zbuffer.WorldToZBufferFrustum.init ((float)zBufferWorldSize, (float)zBufferWorldSize, description.SunDistance, description.SunDistance*2);
// Zbuffer size
zbuffer.ZBufferPixelSize = zBufferPixelSize;
// Evaluate the size of the local zbuffer
// The zone bounding box
CVector bMin = zoneBB.getMin ();
CVector bMax = zoneBB.getMax ();
transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMax.y, bMin.z), zbuffer.BoundingBoxVectors[0]);
transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMin.y, bMin.z), zbuffer.BoundingBoxVectors[1]);
transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMin.y, bMin.z), zbuffer.BoundingBoxVectors[2]);
transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMax.y, bMin.z), zbuffer.BoundingBoxVectors[3]);
transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMax.y, bMax.z), zbuffer.BoundingBoxVectors[4]);
transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMin.y, bMax.z), zbuffer.BoundingBoxVectors[5]);
transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMin.y, bMax.z), zbuffer.BoundingBoxVectors[6]);
transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMax.y, bMax.z), zbuffer.BoundingBoxVectors[7]);
// Get the min and max
zbuffer.LocalZBufferXMin = 0x7fffffff;
zbuffer.LocalZBufferYMin = 0x7fffffff;
zbuffer.LocalZBufferXMax = 0x80000000;
zbuffer.LocalZBufferYMax = 0x80000000;
zbuffer.LocalZBufferZMin = FLT_MAX;
zbuffer.LocalZBufferZMax = -FLT_MAX;
uint j;
for (j=0; j<8; j++)
{
sint minX = (sint)floor (zbuffer.BoundingBoxVectors[j].x);
sint maxX = (sint)ceil (zbuffer.BoundingBoxVectors[j].x);
sint minY = (sint)floor (zbuffer.BoundingBoxVectors[j].y);
sint maxY = (sint)ceil (zbuffer.BoundingBoxVectors[j].y);
if (minX<zbuffer.LocalZBufferXMin)
zbuffer.LocalZBufferXMin = minX;
if (maxX>zbuffer.LocalZBufferXMax)
zbuffer.LocalZBufferXMax = maxX;
if (minY<zbuffer.LocalZBufferYMin)
zbuffer.LocalZBufferYMin = minY;
if (maxY>zbuffer.LocalZBufferYMax)
zbuffer.LocalZBufferYMax = maxY;
if ((-zbuffer.BoundingBoxVectors[j].z)<zbuffer.LocalZBufferZMin)
zbuffer.LocalZBufferZMin = -zbuffer.BoundingBoxVectors[j].z;
if ((-zbuffer.BoundingBoxVectors[j].z)>zbuffer.LocalZBufferZMax)
zbuffer.LocalZBufferZMax = -zbuffer.BoundingBoxVectors[j].z;
}
// Expand the zbuffer
zbuffer.LocalZBufferXMax++;
zbuffer.LocalZBufferXMin--;
zbuffer.LocalZBufferYMax++;
zbuffer.LocalZBufferYMin--;
zbuffer.LocalZBufferWidth = zbuffer.LocalZBufferXMax-zbuffer.LocalZBufferXMin;
zbuffer.LocalZBufferHeight = zbuffer.LocalZBufferYMax-zbuffer.LocalZBufferYMin;
// Resize and clear the zbuffer
zbuffer.Pixels.resize (0);
zbuffer.Pixels.resize (zbuffer.LocalZBufferWidth*zbuffer.LocalZBufferHeight, FLT_MAX);
}
// ***************************************************************************
#ifdef SAVE_ZBUFFER
void SaveZBuffer (CZoneLighter::CZBuffer &zbuffer, const char *filename)
{
// Resize the bitmap
CBitmap bitmap;
bitmap.resize (zbuffer.LocalZBufferWidth, zbuffer.LocalZBufferHeight, CBitmap::Luminance);
// Get pixels
CObjectVector<uint8> &pixels = bitmap.getPixels ();
// Draw it
uint samples = zbuffer.LocalZBufferWidth*zbuffer.LocalZBufferHeight;
for (uint i=0; i<samples; i++)
{
// Get the value
float value = (zbuffer.Pixels[i] - zbuffer.LocalZBufferZMin) * 255 / (zbuffer.LocalZBufferZMax - zbuffer.LocalZBufferZMin);
clamp (value, 0, 255);
pixels[i] = (uint8)value;
}
// Convert to RGBA
bitmap.convertToType (CBitmap::RGBA);
// Draw some red lines
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
draw2dLine (bitmap, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
// Render it
COFile outputZFile;
// Open it
if (outputZFile.open (filename))
{
// Save the new zone
try
{
// Convert to RGBA
bitmap.convertToType (CBitmap::RGBA);
// Save it
bitmap.writeJPG (outputZFile, 128);
}
catch (Exception& except)
{
// Error message
nlwarning ("ERROR writing %s: %s\n", filename, except.what());
}
}
else
{
// Error can't open the file
nlwarning ("ERROR Can't open %s for writing\n", filename);
}
}
#endif // SAVE_ZBUFFER
// ***************************************************************************
void FilterZBuffer (CZoneLighter::CZBuffer &zbuffer, uint filterRadius)
{
// Resize the temp buffer
static std::vector<float> tempPixels;
tempPixels = zbuffer.Pixels;
sint x, y;
for (y=0; y<zbuffer.LocalZBufferHeight; y++)
for (x=0; x<zbuffer.LocalZBufferWidth; x++)
{
// The Value
float &newValue = tempPixels[x+y*zbuffer.LocalZBufferWidth];
uint n;
for (n=1; n<filterRadius; n++)
{
const sint fx = x + DeltaZ[n][0];
const sint fy = y + DeltaZ[n][1];
// Clip
if ( (fx>=0) && (fx < zbuffer.LocalZBufferWidth) && (fy>=0) && (fy < zbuffer.LocalZBufferHeight) )
{
const float &testValue = zbuffer.Pixels[fx+fy*zbuffer.LocalZBufferWidth];
if (testValue < newValue)
newValue = testValue;
}
}
}
// Copy the new zbuffer
zbuffer.Pixels = tempPixels;
}
// ***************************************************************************
void CZoneLighter::light (CLandscape &landscape, CZone& output, uint zoneToLight, const CLightDesc& description, std::vector<CTriangle>& obstacles, vector<uint> &listZone)
{
/*
* Lighting algorithm
* ------------------
*
* - Create a quad grid to store shadow casting triangles
* - Create a heightfield used for global illumination. Cells are initialized with -FLT_MAX
* - Insert each shadow casting triangles in the quad grid and fill the heightfield's cells overlapped by the bounding box of the triangle with
* the max height of the triangle if its height is > than the current height in the heightfield's cell.
* -
*/
// Backup thread mask
IThread *currentThread = IThread::getCurrentThread ();
uint64 threadMask = currentThread->getCPUMask();
currentThread->setCPUMask (1);
// Calc the ray basis
_SunDirection=description.SunDirection;
NEL3DCalcBase (_SunDirection, _RayBasis);
// Zone to light
_ZoneToLight=zoneToLight;
// Landscape
_Landscape=&landscape;
// Process count
_ProcessCount=description.NumCPU;
if (_ProcessCount==0)
{
// Create a doomy thread
IProcess *pProcess=IProcess::getCurrentProcess ();
_CPUMask = pProcess->getCPUMask();
_ProcessCount = 0;
uint64 i;
for (i=0; i<64; i++)
{
if (_CPUMask&((uint64)1<<i))
_ProcessCount++;
}
}
if (_ProcessCount>MAX_CPU_PROCESS)
_ProcessCount=MAX_CPU_PROCESS;
// Number of obstacle polygones
printf ("Obstacle polygones : %zu\n", obstacles.size ());
// Number of CPUS used
printf ("Number of CPU used: %d\n", _ProcessCount);
// Zone pointer
CZone *pZone=landscape.getZone (_ZoneToLight);
if (pZone)
{
// *** Compute center of the object
// Get the zone bounding box
const CAABBoxExt &zoneBB=pZone->getZoneBB();
// Get the center
CVector center = zoneBB.getCenter ();
// *** Compute planes
const uint size=obstacles.size();
uint triangleId;
for (triangleId=0; triangleId<size; triangleId++)
{
// Triangle ref
CZoneLighter::CTriangle& triangle=obstacles[triangleId];
// Calc the plane
triangle._Plane.make (triangle.Triangle.V0, triangle.Triangle.V1, triangle.Triangle.V2);
}
// Create landscape zbuffers
_ZBufferLandscape.resize (description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt);
uint sampleX;
uint sampleY;
for (sampleY=0; sampleY<description.SoftShadowSamplesSqrt; sampleY++)
for (sampleX=0; sampleX<description.SoftShadowSamplesSqrt; sampleX++)
{
// *** Render the light zbuffer
CZBuffer &zbuffer = _ZBufferLandscape[sampleX + sampleY*description.SoftShadowSamplesSqrt];
// Delta pos for area light
float deltaX = ( (float)sampleX + 0.5f - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt;
float deltaY = ( (float)sampleY + 0.5f - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt;
CVector lightPos = _RayBasis.getI () * ((float)description.SunRadius * deltaX) + _RayBasis.getJ () * ((float)description.SunRadius * deltaY);
lightPos = description.SunCenter - (description.SunDirection * description.SunDistance) + lightPos;
InitZBuffer (zbuffer, lightPos, _RayBasis, zoneBB, description.ZBufferLandscapeSize, description);
printf ("Zbuffer %d size : %d x %d\n", sampleX+sampleY*description.SoftShadowSamplesSqrt, zbuffer.LocalZBufferWidth, zbuffer.LocalZBufferHeight);
}
// *** Init the zbuffer for the vegetation
CVector lightPos = description.SunCenter - (description.SunDirection * description.SunDistance);
InitZBuffer (_ZBufferObject, lightPos, _RayBasis, zoneBB, description.ZBufferObjectSize, description);
printf ("Zbuffer object size : %d x %d\n", _ZBufferObject.LocalZBufferWidth, _ZBufferObject.LocalZBufferHeight);
// Compute the zbuffer in multi thread
_ProcessExited = 0;
// Number of triangle to render per thread
uint numTriangle = (obstacles.size () / _ProcessCount) + 1;
// First triangle for the thread
uint firstTriangle = 0;
// Count
_NumberOfPatchComputed = 0;
for (uint process=0; process<_ProcessCount; process++)
{
// Get list of triangles to render
uint lastTriangle=firstTriangle+numTriangle;
if (lastTriangle>obstacles.size ())
lastTriangle=obstacles.size ();
// Create a thread
CRenderZBuffer *runnable = new CRenderZBuffer (process, this, &description, firstTriangle, lastTriangle - firstTriangle, &obstacles);
IThread *pThread=IThread::create (runnable);
runnable->Thread = pThread;
// New first patch
firstTriangle = lastTriangle;
// Launch
pThread->start();
}
// Wait for others processes
while (_ProcessExited!=_ProcessCount)
{
nlSleep (1000);
// Call the progress callback
progress ("Render triangles", (float)_NumberOfPatchComputed/(float)obstacles.size());
}
// * Save the zbuffer
uint sample;
const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt;
#ifdef SAVE_ZBUFFER
for (sample=0; sample<samples; sample++)
{
// *** The zbuffer
CZBuffer &zbuffer = _ZBufferLandscape[sample];
string zbufferFilename = SAVE_ZBUFFER"/zbuffer_landscape_" + toString (sample) + ".jpg";
SaveZBuffer (zbuffer, zbufferFilename.c_str ());
}
// Save the object zbuffer
SaveZBuffer (_ZBufferObject, SAVE_ZBUFFER"/zbuffer_object.jpg");
#endif // SAVE_ZBUFFER
// *** Filter the zbuffer
for (sample=0; sample<samples; sample++)
{
// For landscape zbuffer, expand the z to neighbor
FilterZBuffer (_ZBufferLandscape[sample], 5);
}
// Change the quadGrid basis
CMatrix invRayBasis=_RayBasis;
invRayBasis.invert ();
// Init the heightfield
_HeightfieldCellSize=description.HeightfieldCellSize;
_HeightFieldCellCount=(sint)(description.HeightfieldSize/_HeightfieldCellSize);
nlassert (_HeightFieldCellCount!=0);
_OrigineHeightField=zoneBB.getCenter ()-CVector (description.HeightfieldSize/2, description.HeightfieldSize/2, 0);
_HeightField.resize (_HeightFieldCellCount*_HeightFieldCellCount, -FLT_MAX);
// Fill the quadGrid and the heightField
for (triangleId=0; triangleId<size; triangleId++)
{
// Progress bar
if ( (triangleId&0xff) == 0)
progress ("Build quadtree and heightfield", (float)triangleId/(float)size);
// Triangle ref
CZoneLighter::CTriangle& triangle=obstacles[triangleId];
// Look for the min coordinate, in World Basis
CVector minv;
minv.minof (triangle.Triangle.V0, triangle.Triangle.V1);
minv.minof (minv, triangle.Triangle.V2);
// Look for the max coordinate, in World Basis
CVector maxv;
maxv.maxof (triangle.Triangle.V0, triangle.Triangle.V1);
maxv.maxof (maxv, triangle.Triangle.V2);
// Lanscape tri ?
if (triangle.Flags & CTriangle::Landscape)
{
// Fill the heightfield
sint minX=std::max (0, (sint)floor (0.5f+(minv.x-_OrigineHeightField.x)/_HeightfieldCellSize));
sint maxX=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.x-_OrigineHeightField.x)/_HeightfieldCellSize));
sint minY=std::max (0, (sint)floor (0.5f+(minv.y-_OrigineHeightField.y)/_HeightfieldCellSize));
sint maxY=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.y-_OrigineHeightField.y)/_HeightfieldCellSize));
// Calc position in the heightfield
for (sint y=minY; y<maxY; y++)
for (sint x=minX; x<maxX; x++)
{
// Valid position, try to insert it
if (maxv.z>_HeightField[x+y*_HeightFieldCellCount])
{
// New height in this cell
_HeightField[x+y*_HeightFieldCellCount]=maxv.z;
}
}
}
}
// Retrieve the zone to fill its shaded value
pZone->retrieve (_PatchInfo, _BorderVertices);
// Number of patch
uint patchCount=_PatchInfo.size();
// Bit array to know if the lumel is shadowed
if (description.Shadow)
_ShadowArray.resize (patchCount);
// A lumel vector by patch
vector<vector<CLumelDescriptor> > lumels;
lumels.resize (patchCount);
// Build zone informations
buildZoneInformation (landscape,
listZone,
description);
}
// Number of patch
uint patchCount=_PatchInfo.size();
// Reset patch count
{
CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed);
access.value().resize (0);
access.value().resize (patchCount, false);
}
// Patch by thread
uint patchCountByThread = patchCount/_ProcessCount;
patchCountByThread++;
// Patch to allocate
uint firstPatch=0;
_NumberOfPatchComputed = 0;
// Reset exited process
_ProcessExited=0;
// Set the thread state
_LastPatchComputed.resize (_ProcessCount);
// Launch threads
uint process;
for (process=0; process<_ProcessCount; process++)
{
// Last patch
uint lastPatch=firstPatch+patchCountByThread;
if (lastPatch>patchCount)
lastPatch=patchCount;
// Last patch computed
_LastPatchComputed[process] = firstPatch;
// Create a thread
CLightRunnable *runnable = new CLightRunnable (process, this, &description);
IThread *pThread=IThread::create (runnable);
runnable->Thread = pThread;
// New first patch
firstPatch=lastPatch;
// Launch
pThread->start();
}
// Wait for others processes
while (_ProcessExited!=_ProcessCount)
{
nlSleep (1000);
// Call the progress callback
progress ("Lighting patches", (float)_NumberOfPatchComputed/(float)_PatchInfo.size());
}
// Reset old thread mask
currentThread->setCPUMask (threadMask);
// overflow ?
if (_ZBufferOverflow)
nlwarning ("Error : zbuffer overflow");
// Progress bar
progress ("Compute Influences of PointLights", 0.f);
// Compute PointLight influences on zone.
// Some precalc.
compilePointLightRT(description.GridSize, description.GridCellSize, obstacles, description.Shadow);
// Influence patchs and get light list of interest
std::vector<CPointLightNamed> listPointLight;
processZonePointLightRT(listPointLight);
// Rebuild the zone
// Progress bar
progress ("Compress the lightmap", 0.6f);
// Build, with list of lights.
CZoneInfo zinfo;
zinfo.ZoneId= _ZoneToLight;
zinfo.Patchs= _PatchInfo;
zinfo.BorderVertices= _BorderVertices;
zinfo.PointLights= listPointLight;
output.build (zinfo);
/// copy the tiles flags from the zone to light to the output zone
copyTileFlags(output, *(landscape.getZone(zoneToLight)));
/// Perform lightning of some ig's of the current zone (if any)
lightShapes(zoneToLight, description);
}
// *************************************************************************************
void CZoneLighter::copyTileFlags(CZone &destZone, const CZone &srcZone)
{
nlassert(destZone.getZoneId() == srcZone.getZoneId());
nlassert(destZone.getNumPatchs() == srcZone.getNumPatchs());
for (sint k = 0; k < srcZone.getNumPatchs(); ++k)
{
destZone.copyTilesFlags(k, srcZone.getPatch(k));
}
}
// ***************************************************************************
float CZoneLighter::getSkyContribution(const CVector &pos, const CVector &normal, float skyIntensity) const
{
float s=(pos.x-_OrigineHeightField.x)/_HeightfieldCellSize;
float t=(pos.y-_OrigineHeightField.y)/_HeightfieldCellSize;
sint sInt=(sint)(floor (s+0.5f));
sint tInt=(sint)(floor (t+0.5f));
// Bilinear
float skyContributionTab[2][2];
skyContributionTab[0][0] = calcSkyContribution (sInt-1, tInt-1, pos.z, skyIntensity, normal);
skyContributionTab[1][0] = calcSkyContribution (sInt, tInt-1, pos.z, skyIntensity, normal);
skyContributionTab[1][1] = calcSkyContribution (sInt, tInt, pos.z, skyIntensity, normal);
skyContributionTab[0][1] = calcSkyContribution (sInt-1, tInt, pos.z, skyIntensity, normal);
float sFact=s+0.5f-sInt;
float tFact=t+0.5f-tInt;
return (skyContributionTab[0][0]*(1.f-sFact) + skyContributionTab[1][0]*sFact)*(1.f-tFact) +
(skyContributionTab[0][1]*(1.f-sFact) + skyContributionTab[1][1]*sFact)*tFact;
}
// ***************************************************************************
void CZoneLighter::processCalc (uint process, const CLightDesc& description)
{
// *** Raytrace each patches
// Get a patch
uint patch = getAPatch (process);
while (patch != 0xffffffff)
{
// For each patch
if (description.Shadow)
{
// Lumels
std::vector<CLumelDescriptor> &lumels=_Lumels[patch];
// Lumel count
uint lumelCount=lumels.size();
CPatchInfo &patchInfo=_PatchInfo[patch];
nlassert (patchInfo.Lumels.size()==lumelCount);
// Resize shadow array
_ShadowArray[patch].resize (lumelCount);
// For each lumel
for (uint lumel=0; lumel<lumelCount; lumel++)
{
float factor=0;
factor = attenuation (lumels[lumel].Position, description);
patchInfo.Lumels[lumel]=(uint)(factor*255);
}
}
else
{
// Lumels
std::vector<CLumelDescriptor> &lumels=_Lumels[patch];
// Lumel count
uint lumelCount=lumels.size();
CPatchInfo &patchInfo=_PatchInfo[patch];
nlassert (patchInfo.Lumels.size()==lumelCount);
// For each lumel
for (uint lumel=0; lumel<lumelCount; lumel++)
{
// Not shadowed
patchInfo.Lumels[lumel]=255;
}
}
// *** Lighting
// Get the patch info
CPatchInfo &patchInfo=_PatchInfo[patch];
// ** Pointer on arries
std::vector<CLumelDescriptor> &lumels=_Lumels[patch];
// Go for light each lumel
for (uint lumel=0; lumel<lumels.size(); lumel++)
{
// Sky contribution
float skyContribution;
if (description.SkyContribution)
{
skyContribution = getSkyContribution(lumels[lumel].Position, lumels[lumel].Normal, description.SkyIntensity);
}
else
{
skyContribution = 0.f;
}
// Sun contribution
float sunContribution;
if (description.SunContribution)
{
sunContribution=(-lumels[lumel].Normal*_SunDirection)-skyContribution;
clamp (sunContribution, 0.f, 1.f);
}
else
sunContribution=0;
// Final lighting
sint finalLighting=(sint)(255.f*(((float)patchInfo.Lumels[lumel])*sunContribution/255.f+skyContribution));
clamp (finalLighting, 0, 255);
patchInfo.Lumels[lumel]=finalLighting;
}
// Next patch
patch = getAPatch (process);
}
}
// ***************************************************************************
uint8 CZoneLighter::getMaxPhi (sint s, sint t, sint deltaS, sint deltaT, float heightPos) const
{
// Start position
s+=deltaS;
t+=deltaT;
// Distance increment
float stepDistance=CVector (deltaS*_HeightfieldCellSize, deltaT*_HeightfieldCellSize,0).norm ();
// Current distance
float distance=stepDistance;
// Max height
float maxHeight=0;
float maxTanTeta=0;
// For all the line
while ((s<_HeightFieldCellCount)&&(t<_HeightFieldCellCount)&&(s>=0)&&(t>=0))
{
// Get height
float height=_HeightField[s+t*_HeightFieldCellCount];
height-=heightPos;
// Better ?
if (height>maxHeight)
{
// Calc sin teta
float tanTeta=height/distance;
nlassert (tanTeta>=0);
// Better ?
if (tanTeta>maxTanTeta)
{
// New max height
maxHeight=height;
maxTanTeta=tanTeta;
}
}
s+=deltaS;
t+=deltaT;
distance+=stepDistance;
}
// return phi
float teta=(float)atan (maxTanTeta);
nlassert (teta>=0);
nlassert (teta<=Pi/2);
clamp (teta, 0.f, (float)Pi/2);
sint res=(sint)((Pi/2-teta)*256/(Pi/2));
clamp (res, 0, 255);
return (uint8)res;
}
// ***************************************************************************
#define AllFront 0
#define AllBack 1
#define Clipped 2
// ***************************************************************************
bool CZoneLighter::isLumelOnEdgeMustBeOversample (uint patch, uint edge, sint s, sint t, const vector<bool> &binded,
const vector<bool> &oversampleEdges, vector<CPatchUVLocator> &locator,
uint8 shadowed, vector<vector<uint8> >& shadowBuffer)
{
// Must force oversampling of this edge ?
if (oversampleEdges[edge])
return true;
else
{
// binded ?
if (binded[edge])
{
// Lumel coord
CVector2f lumelCoord (((float)(s+_GetNormalDeltaS[edge])+0.5f)/4.f, ((float)(t+_GetNormalDeltaT[edge])+0.5f)/4.f);
uint otherPatch=locator[edge].selectPatch(lumelCoord);
// Get uv
CVector2f neighborUV;
CPatch *patchOut;
locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV);
// Is the same shadowed flag ?
sint ss=(sint)(neighborUV.x*4.f);
sint tt=(sint)(neighborUV.y*4.f);
return (shadowBuffer[patchOut->getPatchId()][ss+(patchOut->getOrderS()<<2)*tt]!=shadowed);
}
else
{
// Not oversample if not binded
return false;
}
}
}
// ***************************************************************************
float easineasoutC2(float x)
{
float y;
// 5-nome tq f(0)=0, f'(0)=0, f''(0)=0, f(1)=1, f'(1)=0, f''(1)=0.
float x3=x*x*x;
float x4=x3*x;
float x5=x4*x;
y= 6*x5 -15*x4 +10*x3;
return y;
}
// ***************************************************************************
sint16 CZoneLighter::_GetNormalDeltaS[4]={ -1, 0, 1, 0 };
sint16 CZoneLighter::_GetNormalDeltaT[4]={ 0, 1, 0, -1 };
// ***************************************************************************
void CZoneLighter::getNormal (const CPatch *pPatch, sint16 lumelS, sint16 lumelT, vector<CPatchUVLocator> &locator,
const vector<CPatch::CBindInfo> &bindInfo, const vector<bool> &binded, set<uint64>& visited,
float deltaS, float deltaT, uint rotation, const CBezierPatch &bezierPatch, uint lastEdge)
{
// Build a desc srructure
uint64 id=(uint64)lumelS|(((uint64)lumelT)<<16)|(((uint64)pPatch->getPatchId())<<32)|(((uint64)pPatch->getZone()->getZoneId())<<48);
// Insert it
if (visited.insert (id).second)
{
// Clip
float sqDist=deltaS*deltaS+deltaT*deltaT;
if ( sqDist < 1 )
{
// Continue...
sint orderSx4=pPatch->getOrderS()<<2;
sint orderTx4=pPatch->getOrderT()<<2;
sint16 _GetNormalBorderS[4]={ 0, -10, 1, -10 };
sint16 _GetNormalBorderT[4]={ -10, 1, -10, 0 };
_GetNormalBorderS[2]=orderSx4-1;
_GetNormalBorderT[1]=orderTx4-1;
// Add normal
_GetNormalNormal+=bezierPatch.evalNormal ( ((float)lumelS+0.5f)/(float)orderSx4, ((float)lumelT+0.5f)/(float)orderTx4 );
// For the four neighbors
for (uint edge=0; edge<4; edge++)
{
// Not last edge ?
if (edge!=lastEdge)
{
// Direction
uint globalDirection=(edge+(4-rotation))&0x3;
// Neighbor
if ( (lumelS==_GetNormalBorderS[edge]) || (lumelT==_GetNormalBorderT[edge]) )
{
// Binded ?
bool bind=binded[edge];
bool smooth=pPatch->getSmoothFlag (edge);
if (bind&&smooth)
{
// Lumel coord
CVector2f lumelCoord ( ((float)(lumelS+_GetNormalDeltaS[edge])+0.5f)/4,
((float)(lumelT+_GetNormalDeltaT[edge])+0.5f)/4 );
// Get neighbor pixel
uint otherPatch=locator[edge].selectPatch(lumelCoord);
// Get uv
CVector2f neighborUV;
CPatch *patchOut;
locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV);
// New coordinates
sint16 newLumelS=(sint16)(4.f*neighborUV.x);
sint16 newLumelT=(sint16)(4.f*neighborUV.y);
// Zone id
uint16 patchId=patchOut->getPatchId();
uint16 zoneId=_ZoneId[patchOut->getZone()->getZoneId ()];
// Get edge
uint newEdge=0;
uint i;
for (i=0; i<=(uint)bindInfo[edge].NPatchs; i++)
{
// Good patch ?
if (bindInfo[edge].Next[i]==patchOut)
{
// Get its edge
newEdge=bindInfo[edge].Edge[i];
break;
}
}
// Rotation
uint newRotation=(2-edge+rotation+newEdge)&0x3;
// Must found it
nlassert (i!=(uint)bindInfo[edge].NPatchs);
// Get the bezier patch
CBezierPatch &NewBezierPatch=_BezierPatch[zoneId][patchId];
// Next lumel
getNormal (patchOut, newLumelS, newLumelT, _Locator[zoneId][patchId], _BindInfo[zoneId][patchId],
_Binded[zoneId][patchId], visited, deltaS+_GetNormalDeltaS[globalDirection],
deltaT+_GetNormalDeltaT[globalDirection], newRotation, NewBezierPatch, newEdge);
}
}
else
{
// Left internal
getNormal (pPatch, lumelS+_GetNormalDeltaS[edge], lumelT+_GetNormalDeltaT[edge], locator, bindInfo, binded, visited,
deltaS+_GetNormalDeltaS[globalDirection], deltaT+_GetNormalDeltaT[globalDirection], rotation, bezierPatch, (edge+2)&0x3);
}
}
}
}
}
}
// ***************************************************************************
void CZoneLighter::addTriangles (CLandscape &landscape, vector<uint> &listZone, uint order, std::vector<CTriangle>& triangleArray)
{
// Set all to refine
excludeAllPatchFromRefineAll (landscape, listZone, false);
// Setup the landscape
landscape.setThreshold (0);
landscape.setTileMaxSubdivision (order);
// Refine it
landscape.refineAll (CVector (0, 0, 0));
// Dump tesselated triangles
std::vector<const CTessFace*> leaves;
landscape.getTessellationLeaves(leaves);
// Number of leaves
uint leavesCount=leaves.size();
// Reserve the array
triangleArray.reserve (triangleArray.size()+leavesCount);
// Scan each leaves
for (uint leave=0; leave<leavesCount; leave++)
{
// Leave
const CTessFace *face=leaves[leave];
// Add a triangle
triangleArray.push_back (CTriangle (NLMISC::CTriangle (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos)));
}
// Setup the landscape
landscape.setThreshold (1000);
landscape.setTileMaxSubdivision (0);
// Remove all triangles
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
landscape.refineAll (CVector (0, 0, 0));
}
// ***************************************************************************
void CZoneLighter::addTriangles (const IShape &shape, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
// Cast to CMesh
const CMesh *mesh=dynamic_cast<const CMesh*>(&shape);
// Cast to CMeshMultiLod
const CMeshMultiLod *meshMulti=dynamic_cast<const CMeshMultiLod*>(&shape);
// Cast to CMeshMultiLod
const CMeshMRM *meshMRM=dynamic_cast<const CMeshMRM*>(&shape);
// It is a mesh ?
if (mesh)
{
// Add its triangles
addTriangles (*mesh, mesh->getMeshGeom (), modelMT, triangleArray);
}
// It is a CMeshMultiLod ?
else if (meshMulti)
{
// Get the first geommesh
const IMeshGeom *meshGeom=&meshMulti->getMeshGeom (0);
// Dynamic cast
const CMeshGeom *geomMesh=dynamic_cast<const CMeshGeom*>(meshGeom);
if (geomMesh)
{
addTriangles (*meshMulti, *geomMesh, modelMT, triangleArray);
}
// Dynamic cast
const CMeshMRMGeom *mrmGeomMesh=dynamic_cast<const CMeshMRMGeom*>(meshGeom);
if (mrmGeomMesh)
{
addTriangles (*meshMulti, *mrmGeomMesh, modelMT, triangleArray);
}
}
// It is a CMeshMultiLod ?
else if (meshMRM)
{
// Get the first lod mesh geom
addTriangles (*meshMRM, meshMRM->getMeshGeom (), modelMT, triangleArray);
}
}
// ***************************************************************************
void CZoneLighter::addTriangles (const CMeshBase &meshBase, const CMeshGeom &meshGeom, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
// Get the vertex buffer
const CVertexBuffer &vb=meshGeom.getVertexBuffer();
CVertexBufferRead vba;
vb.lock (vba);
// For each matrix block
uint numBlock=meshGeom.getNbMatrixBlock();
for (uint block=0; block<numBlock; block++)
{
// For each render pass
uint numRenderPass=meshGeom.getNbRdrPass(block);
for (uint pass=0; pass<numRenderPass; pass++)
{
// Get the primitive block
const CIndexBuffer &primitive=meshGeom.getRdrPassPrimitiveBlock ( block, pass);
// Get the material
const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial ( block, pass));
// ** Get the bitmap
// Texture informations, not NULL only if texture is used for alpha test
CBitmap *texture;
bool clampU;
bool clampV;
uint8 alphaTestThreshold;
bool doubleSided;
if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided))
{
// Dump triangles
CIndexBufferRead iba;
primitive.lock (iba);
if (iba.getFormat() == CIndexBuffer::Indices32)
{
const uint32* triIndex= (const uint32*) iba.getPtr ();
uint numTri=primitive.getNumIndexes ()/3;
uint tri;
for (tri=0; tri<numTri; tri++)
{
// Vertex
CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));
// UV
float u[3];
float v[3];
for (uint i=0; i<3; i++)
{
// Get UV coordinates
const float *uv = (const float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
if (uv)
{
// Copy it
u[i] = uv[0];
v[i] = uv[1];
}
}
// Make a triangle
triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
alphaTestThreshold));
}
}
else
{
const uint16* triIndex=(const uint16*)iba.getPtr ();
uint numTri=primitive.getNumIndexes ()/3;
uint tri;
for (tri=0; tri<numTri; tri++)
{
// Vertex
CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));
// UV
float u[3];
float v[3];
for (uint i=0; i<3; i++)
{
// Get UV coordinates
const float *uv = (const float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
if (uv)
{
// Copy it
u[i] = uv[0];
v[i] = uv[1];
}
}
// Make a triangle
triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
alphaTestThreshold));
}
}
}
}
}
}
// ***************************************************************************
bool CZoneLighter::getTexture (const CMaterial &material, CBitmap *&result, bool &clampU, bool &clampV, uint8 &alphaTestThreshold, bool &doubleSided)
{
// Texture informations, not NULL only if texture is used for alpha test
result = NULL;
clampU = false;
clampV = false;
// Alpha test threashold
float alphaTestThresholdF = material.getAlphaTestThreshold () * 255;
clamp (alphaTestThresholdF, 0.f, 255.f);
alphaTestThreshold = (uint8)alphaTestThresholdF;
// Drawable material ?
if (material.getBlend ())
return false;
// Use alpha test ?
if (material.getAlphaTest ())
{
// Get the texture
ITexture *texture = material.getTexture (0);
// Is texture shared ?
if (texture && texture->supportSharing ())
{
// Share name
string name = texture->getShareName();
// Texture exist ?
std::map<string, NLMISC::CBitmap>::iterator ite = _Bitmaps.find (name);
if (ite != _Bitmaps.end ())
{
// Yes
result = &(ite->second);
}
else
{
// No, add it
ite = _Bitmaps.insert (std::map<string, NLMISC::CBitmap>::value_type (name, CBitmap())).first;
result = &(ite->second);
// Generate the texture
texture->generate ();
// Convert to RGBA
texture->convertToType (CBitmap::RGBA);
// Copy it
*result = *texture;
// Release the texture
texture->release ();
}
// Wrap flags
clampU = texture->getWrapS () == ITexture::Clamp;
clampV = texture->getWrapT () == ITexture::Clamp;
}
}
// Get double sided flag
doubleSided = material.getDoubleSided ();
return true;
}
// ***************************************************************************
void CZoneLighter::addTriangles (const CMeshBase &meshBase, const CMeshMRMGeom &meshGeom, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
// Get the vertex buffer
const CVertexBuffer &vb=meshGeom.getVertexBuffer();
CVertexBufferRead vba;
vb.lock (vba);
// For each render pass
uint numRenderPass=meshGeom.getNbRdrPass(0);
for (uint pass=0; pass<numRenderPass; pass++)
{
// Get the primitive block
const CIndexBuffer &primitive=meshGeom.getRdrPassPrimitiveBlock ( 0, pass);
// Get the material
const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial (0, pass));
// ** Get the bitmap
// Texture informations, not NULL only if texture is used for alpha test
CBitmap *texture;
bool clampU;
bool clampV;
uint8 alphaTestThreshold;
bool doubleSided;
if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided))
{
// Dump triangles
CIndexBufferRead iba;
primitive.lock (iba);
const uint32* triIndex= (const uint32 *) iba.getPtr ();
uint numTri=primitive.getNumIndexes ()/3;
uint tri;
for (tri=0; tri<numTri; tri++)
{
// Vertex
CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));
// UV
float u[3];
float v[3];
for (uint i=0; i<3; i++)
{
// Get UV coordinates
float *uv = (float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
if (uv)
{
// Copy it
u[i] = uv[0];
v[i] = uv[1];
}
}
// Make a triangle
triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
alphaTestThreshold));
}
}
}
}
// ***************************************************************************
void CZoneLighter::excludeAllPatchFromRefineAll (CLandscape &landscape, vector<uint> &listZone, bool exclude)
{
// For each zone
for (uint zone=0; zone<listZone.size(); zone++)
{
// Get num patches
uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();
// For each patches
for (uint patch=0; patch<patchCount; patch++)
{
// Exclude all the patches from refine all
landscape.excludePatchFromRefineAll (listZone[zone], patch, exclude);
}
}
}
// ***************************************************************************
const sint8 CZoneLighter::TriangleIndexes[10][2][3] =
{
{{0, 11, 6}, {0, 6, 9}},
{{9, 6, 4}, {4, 6, 14}},
{{4, 14, 8}, {4, 8, 10}},
{{10, 8, 1}, {-1, -1, -1}},
{{11, 5, 6}, {5, 13, 6}},
{{6, 13, 3}, {6, 3, 14}},
{{3, 8, 14}, {-1, -1, -1}},
{{5, 12, 7}, {5, 7, 13}},
{{7, 3, 13}, {-1, -1, -1}},
{{12, 2, 7}, {-1, -1, -1}}
};
// ***************************************************************************
// lumel vertex ID, tesselation edge ID (0 for base<->right, 1 for base<->left), tesselation edge vertex 0, tesselation edge vertex 1
const sint8 CZoneLighter::VertexThanCanBeSnappedOnABorder[8][4] =
{
{0, 0, 0, 9},
{1, 0, 9, 4},
{2, 0, 4, 10},
{3, 0, 10, 1},
{0, 1, 0, 11},
{4, 1, 11, 5},
{7, 1, 5, 12},
{9, 1, 12, 2},
};
// ***************************************************************************
// lumel vertex ID, tesselation corner vertex
const sint8 CZoneLighter::VertexThanCanBeSnappedOnACorner[3][2] =
{
{0, 0},
{3, 1},
{9, 2},
};
// ***************************************************************************
void CZoneLighter::buildZoneInformation (CLandscape &landscape, const vector<uint> &listZone, const CLightDesc &lightDesc)
{
// Bool visit
vector<vector<uint> > visited;
// Zone count
uint zoneCount=listZone.size();
// Resize arries
_Locator.resize (zoneCount);
_Binded.resize (zoneCount);
_BindInfo.resize (zoneCount);
_BezierPatch.resize (zoneCount);
// For each zone
for (uint zone=0; zone<zoneCount; zone++)
{
// Get num patches
uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();
// Insert zone id
_ZoneId.insert (map<uint, uint>::value_type (listZone[zone], zone));
// This is the zone to light ?
if (listZone[zone]==_ZoneToLight)
{
// Resize the arraies
_Lumels.resize(patchCount);
// _LumelCorners.resize(patchCount);
// _BezierPatch.resize(patchCount);
_OversampleEdges.resize(patchCount);
visited.resize(patchCount);
}
// Common arries
_Locator[zone].resize(patchCount);
_Binded[zone].resize(patchCount);
_BindInfo[zone].resize(patchCount);
_BezierPatch[zone].resize(patchCount);
// For each patch
uint patch;
for (patch=0; patch<patchCount; patch++)
{
// Get a patch pointer
const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(listZone[zone])))->getPatch (patch);
// Progress bar
progress ("Scan all patches", (float)patch/(float)patchCount);
// Get pointer on arries
vector<bool> &binded=_Binded[zone][patch];
vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zone][patch];
vector<CPatchUVLocator> &locator=_Locator[zone][patch];
CBezierPatch &bezierPatch=_BezierPatch[zone][patch];
binded.resize (4, false);
bindInfo.resize (4);
locator.resize (4);
// Contruct the patch
bezierPatch=*pPatch->unpackIntoCache();
// Same zone ?
if (listZone[zone]==_ZoneToLight)
{
// oversample this edge
_OversampleEdges[patch].resize (4, false);
}
// *** Build bind info
// *** Build neighboorhood information
uint edge;
for (edge=0; edge<4; edge++)
{
// Bond neighbor
pPatch->getBindNeighbor (edge, bindInfo[edge]);
// Patch binded
if (bindInfo[edge].NPatchs>0)
{
// This edeg is binded
binded[edge]=true;
// Same zone ?
if ((listZone[zone]==_ZoneToLight)&&(bindInfo[edge].Zone->getZoneId()!=_ZoneToLight))
{
// oversample this edge
_OversampleEdges[patch][edge]=true;
}
locator[edge].build (pPatch, edge, bindInfo[edge]);
}
else
{
if (listZone[zone]==_ZoneToLight)
{
// oversample this edge
_OversampleEdges[patch][edge]=true;
}
}
}
// This is the zone to light ?
if (listZone[zone]==_ZoneToLight)
{
// *** Resize lumel array for this patch
// Get patch order
uint orderS=pPatch->getOrderS();
uint orderT=pPatch->getOrderT();
// Number of lumels
uint lumelCount = orderS*orderT*16;
// Resize the lumel descriptor
CLumelDescriptor descriptor;
descriptor.Normal.set (0,0,0);
descriptor.Position.set (0,0,0);
descriptor.S=0;
descriptor.T=0;
_Lumels[patch].resize (lumelCount, descriptor);
visited[patch].resize (lumelCount, 0);
// _LumelCorners[patch].resize (lumelCornerCount);
// *** Unexclude this patch
// Exclude all the patches from refine all
landscape.excludePatchFromRefineAll (listZone[zone], patch, false);
}
else
{
// Exclude all the patches from refine all
landscape.excludePatchFromRefineAll (listZone[zone], patch, true);
}
}
}
// *** Now tesselate this zone to shadow casters accuracy
// Setup the landscape
landscape.setThreshold (0);
landscape.setTileMaxSubdivision (0);
// Refine all
progress ("Refine landscape to shadow accuracy", 0.5f);
landscape.refineAll (CVector (0, 0, 0));
// Get tesselated faces
std::vector<const CTessFace*> leaves;
landscape.getTessellationLeaves(leaves);
if (_WaterShapes.size() != 0) // any water shape in this zone ?
{
/// make a quad grid of each water shape
makeQuadGridFromWaterShapes(landscape.getZone(_ZoneToLight)->getZoneBB().getAABBox());
/// check for each tile if it is above / below water
computeTileFlagsForPositionTowardWater(lightDesc, leaves);
}
else
{
setTileFlagsToDefault(leaves);
}
// Id of this zone in the array
uint zoneNumber=_ZoneId[_ZoneToLight];
// Scan each leaves
uint leavesCount=leaves.size();
uint leave;
for (leave=0; leave<leavesCount; leave++)
{
// Progress bar
if ( (leave&0xff) == 0)
progress ("Precompute lumel position", (float)leave/(float)leavesCount);
// Leave
const CTessFace *face=leaves[leave];
// Get zone id
if (face->Patch->getZone()->getZoneId()==_ZoneToLight)
{
// Get a patch pointer
const CPatch* pPatch=face->Patch;
// Get order
uint orderS=pPatch->getOrderS();
uint orderT=pPatch->getOrderT();
// *** Base Coordinates
CVector pos[15];
pos[0]=face->VBase->EndPos; // p0
pos[1]=face->VRight->EndPos;
pos[2]=face->VLeft->EndPos; // p2
pos[3]=(pos[1]+pos[2])/2;
pos[4]=(pos[0]+pos[1])/2; // p4
pos[5]=(pos[0]+pos[2])/2;
pos[6]=(pos[0]+pos[3])/2; // p6
pos[7]=(pos[2]+pos[3])/2;
pos[8]=(pos[1]+pos[3])/2; // p8
pos[9]=(pos[0]+pos[4])/2;
pos[10]=(pos[1]+pos[4])/2; // p10
pos[11]=(pos[0]+pos[5])/2;
pos[12]=(pos[2]+pos[5])/2; // p12
pos[13]=(pos[3]+pos[5])/2;
pos[14]=(pos[3]+pos[4])/2; // p14
float s0=face->PVBase.getS();
float s1=face->PVRight.getS();
float s2=face->PVLeft.getS();
float s3=(s1+s2)/2;
float s4=(s0+s1)/2;
float s5=(s0+s2)/2;
float s6=(s4+s5)/2;
float s7=(s2+s3)/2;
float s8=(s1+s3)/2;
float t0=face->PVBase.getT();
float t1=face->PVRight.getT();
float t2=face->PVLeft.getT();
float t3=(t1+t2)/2;
float t4=(t0+t1)/2;
float t5=(t0+t2)/2;
float t6=(t4+t5)/2;
float t7=(t2+t3)/2;
float t8=(t1+t3)/2;
// *** Interpolated value
CVector interpolatedP[10]=
{
(pos[0]+pos[6])/2,
(pos[4]+pos[6])/2,
(pos[4]+pos[8])/2,
(pos[1]+pos[8])/2,
(pos[5]+pos[6])/2,
(pos[3]+pos[6])/2,
(pos[3]+pos[8])/2,
(pos[5]+pos[7])/2,
(pos[3]+pos[7])/2,
(pos[2]+pos[7])/2,
};
// Does the border are snapped ?
uint sBase = (uint)floor ((float)orderS * face->PVBase.getS() + 0.5);
uint tBase = (uint)floor ((float)orderT * face->PVBase.getT() + 0.5);
uint sLeft = (uint)floor ((float)orderS * face->PVLeft.getS() + 0.5);
uint tLeft = (uint)floor ((float)orderT * face->PVLeft.getT() + 0.5);
uint sRight = (uint)floor ((float)orderS * face->PVRight.getS() + 0.5);
uint tRight = (uint)floor ((float)orderT * face->PVRight.getT() + 0.5);
bool snapedLeft[2]=
{
(sBase == 0) && (sRight == 0),
(sBase == 0) && (sLeft == 0),
};
bool snapedRight[2]=
{
(sBase == orderS) && (sRight == orderS),
(sBase == orderS) && (sLeft == orderS),
};
bool snapedTop[2]=
{
(tBase == 0) && (tRight == 0),
(tBase == 0) && (tLeft == 0),
};
bool snapedBottom[2]=
{
(tBase == orderT) && (tRight == orderT),
(tBase == orderT) && (tLeft == orderT),
};
bool snapedBorder[2]=
{
snapedLeft[0]||snapedRight[0]||snapedTop[0]||snapedBottom[0],
snapedLeft[1]||snapedRight[1]||snapedTop[1]||snapedBottom[1],
};
bool snapedCorner[3]=
{
((sBase == 0) && ((tBase == 0) || (tBase == orderT))) ||
((sBase == orderS) && ((tBase == 0) || (tBase == orderT))),
((sRight == 0) && ((tRight == 0) || (tRight == orderT))) ||
((sRight == orderS) && ((tRight == 0) || (tRight == orderT))),
((sLeft == 0) && ((tLeft == 0) || (tLeft == orderT))) ||
((sLeft == orderS) && ((tLeft == 0) || (tLeft == orderT))),
};
// Snap on the border
uint i;
for (i=0; i<8; i++)
{
// Snaped on left ?
if (snapedBorder[VertexThanCanBeSnappedOnABorder[i][1]])
{
// Compute the border vertex
interpolatedP[VertexThanCanBeSnappedOnABorder[i][0]] = (pos[VertexThanCanBeSnappedOnABorder[i][2]]
+ pos[VertexThanCanBeSnappedOnABorder[i][3]])/2;
}
}
// Snap on the corner
for (i=0; i<3; i++)
{
// Snaped on a corner ?
uint tesselCornerIndex = VertexThanCanBeSnappedOnACorner[i][1];
if ( snapedCorner[tesselCornerIndex] )
{
// Compute the border vertex
interpolatedP[VertexThanCanBeSnappedOnACorner[i][0]] = pos[tesselCornerIndex];
}
}
float interpolatedS[10]=
{
(s0+s6)/2,
(s4+s6)/2,
(s4+s8)/2,
(s1+s8)/2,
(s5+s6)/2,
(s3+s6)/2,
(s3+s8)/2,
(s5+s7)/2,
(s3+s7)/2,
(s2+s7)/2,
};
float interpolatedT[10]=
{
(t0+t6)/2,
(t4+t6)/2,
(t4+t8)/2,
(t1+t8)/2,
(t5+t6)/2,
(t3+t6)/2,
(t3+t8)/2,
(t5+t7)/2,
(t3+t7)/2,
(t2+t7)/2,
};
for (i=0; i<10; i++)
{
sint s=(sint)((float)orderS*4*interpolatedS[i]);
sint t=(sint)((float)orderT*4*interpolatedT[i]);
if ((s>=0)&&(s<(sint)orderS*4)&&(t>=0)&&(t<(sint)orderT*4))
{
// Triangle index
uint index=s+t*orderS*4;
// Ge tthe patch id
uint patchId=pPatch->getPatchId();
// Get lumel array
vector<CLumelDescriptor> &lumels=_Lumels[patchId];
// Visited
visited[patchId][index]++;
// Position
lumels[index].Position+=interpolatedP[i];
}
}
}
}
// *** Now, finalise patch informations for shadow source positions
// For each patches
uint patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs();
uint patch;
for (patch=0; patch<patchCount; patch++)
{
// Info
progress ("Finalize lumel positions", (float)patch/(float)patchCount);
// *** Resize lumel array for this patch
// Get a patch pointer
const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch);
uint orderS=pPatch->getOrderS();
uint orderT=pPatch->getOrderT();
// Get lumel array
vector<CLumelDescriptor> &lumels=_Lumels[patch];
// *** Average position
// Renormalize
nlassert (isPowerOf2 (orderS));
nlassert (isPowerOf2 (orderT));
uint lumelS=4<<getPowerOf2 (orderS);
uint lumelT=4<<getPowerOf2 (orderT);
for (uint t=0; t<lumelT; t++)
for (uint s=0; s<lumelS; s++)
{
// Lumel index
uint lumelIndex=s+t*lumelS;
// *** Number of visit
uint visitedCount=visited[patch][lumelIndex];
// If visited, renormalise other values
if (visitedCount)
{
// Normalise position
lumels[lumelIndex].Position/=(float)visitedCount;
}
// Not visited for next pass
visited[patch][lumelIndex]=false;
}
}
// *** Now tesselate this zone to shadow receivers accuracy
// Setup the landscape
landscape.setThreshold (0);
landscape.setTileMaxSubdivision (4);
// Refine all
progress ("Refine landscape to lumels", 0.5f);
landscape.refineAll (CVector (0, 0, 0));
// Get tesselated faces
leaves.clear ();
landscape.getTessellationLeaves(leaves);
// Scan each leaves
leavesCount=leaves.size();
for (leave=0; leave<leavesCount; leave++)
{
// Progress bar
if ( (leave&0xff) == 0)
progress ("Precompute tesselation", (float)leave/(float)leavesCount);
// Leave
const CTessFace *face=leaves[leave];
// Get zone id
if (face->Patch->getZone()->getZoneId()==_ZoneToLight)
{
// Get a patch pointer
const CPatch* pPatch=face->Patch;
// Get order
uint orderS=pPatch->getOrderS();
uint orderT=pPatch->getOrderT();
// Coordinates
float fS=(face->PVBase.getS()+face->PVLeft.getS()+face->PVRight.getS())/3.f;
float fT=(face->PVBase.getT()+face->PVLeft.getT()+face->PVRight.getT())/3.f;
uint s=(uint)((float)orderS*4*fS);
uint t=(uint)((float)orderT*4*fT);
//nlassert (s>=0);
nlassert (s<orderS*4);
//nlassert (t>=0);
nlassert (t<orderT*4);
// Triangle index
uint index=s+t*orderS*4;
// Ge tthe patch id
uint patchId=pPatch->getPatchId();
// Get lumel array
vector<CLumelDescriptor> &lumels=_Lumels[patchId];
// Visited
visited[patchId][index]++;
// Lumel s and t
lumels[index].S+=fS;
lumels[index].T+=fT;
// Normal
CPlane plane;
plane.make (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos);
lumels[index].Normal+=plane.getNormal();
}
}
// *** Now, finalise patch informations
// For each patches
patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs();
for (patch=0; patch<patchCount; patch++)
{
// Info
progress ("Finalize patches", (float)patch/(float)patchCount);
// *** Resize lumel array for this patch
// Get a patch pointer
const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch);
uint orderS=pPatch->getOrderS();
uint orderT=pPatch->getOrderT();
// Get lumel array
vector<CLumelDescriptor> &lumels=_Lumels[patch];
// *** Compute an interpolated normal
// Get pointer on arries
vector<bool> &binded=_Binded[zoneNumber][patch];
vector<CPatchUVLocator> &locator=_Locator[zoneNumber][patch];
vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zoneNumber][patch];
CBezierPatch &bezierPatch=_BezierPatch[zoneNumber][patch];
// Renormalize
nlassert (isPowerOf2 (orderS));
nlassert (isPowerOf2 (orderT));
uint powerS=getPowerOf2 (orderS);
uint powerT=getPowerOf2 (orderT);
uint lumelS=4<<powerS;
uint lumelT=4<<powerT;
// Sample edge normal
CVector normals[NL_MAX_TILES_BY_PATCH_EDGE*NL_LUMEL_BY_TILE+1][4];
uint sFixed[4] = { 0, 0xffffffff, lumelS-1, 0xffffffff };
uint tFixed[4] = { 0xffffffff, lumelT-1, 0xffffffff, 0 };
float sOri[4] = { 0, -1, (float)lumelS, -1 };
float tOri[4] = { -1, (float)lumelT, -1, 0 };
for (uint edge=0; edge<4; edge++)
{
// s and t
uint count=(edge&1)?lumelS:lumelT;
for (uint lumel=0; lumel<=count; lumel++)
{
// Start coordinates
float origineS;
float origineT;
uint startS;
uint startT;
if (edge&1)
{
if (lumel==count)
startS=count-1;
else
startS=lumel;
startT=tFixed[edge];
origineS=(float)lumel;
origineT=tOri[edge];
}
else
{
if (lumel==count)
startT=count-1;
else
startT=lumel;
startS=sFixed[edge];
origineT=(float)lumel;
origineS=sOri[edge];
}
_GetNormalNormal=CVector::Null;
set<uint64> visitedLumels;
getNormal (pPatch, startS, startT, locator, bindInfo, binded, visitedLumels,
startS+0.5f-origineS, startT+0.5f-origineT, 0, bezierPatch);
_GetNormalNormal.normalize ();
normals[lumel][edge]=_GetNormalNormal;
}
// Smooth the corners
#define BLUR_SIZE 4
for (uint i=1; i<BLUR_SIZE; i++)
{
float value=(float)i/BLUR_SIZE;
value=easineasout(value);
normals[i][edge]=normals[0][edge]*(1-value)+normals[i][edge]*value;
normals[i][edge].normalize();
normals[count-i][edge]=normals[count][edge]*(1-value)+normals[count-i][edge]*value;
normals[count-i][edge].normalize();
}
}
for (uint t=0; t<lumelT; t++)
for (uint s=0; s<lumelS; s++)
{
// Lumel index
uint lumelIndex=s+t*lumelS;
// *** Calc the smoothed normal
// For each edge
CVector normalS=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT);
float sFactor=0;
CVector normalT=normalS;
float tFactor=0;
bool sGood=false, tGood=false;
if (s<BLUR_SIZE)
{
sGood=true;
// Average the two normals
CVector average=normals[t][0];
average+=normals[t+1][0];
average/=2;
// Blend
float value=s+0.5f;
sFactor=BLUR_SIZE-value;
value/=BLUR_SIZE;
value=easineasout(value);
normalS=(normalS*value+average*(1-value));
normalS.normalize();
}
if (s>=lumelS-BLUR_SIZE)
{
sGood=true;
// Average the two normals
CVector average=normals[t][2];
average+=normals[t+1][2];
average/=2;
// Blend
float value=s+0.5f;
sFactor=BLUR_SIZE-(lumelS-value);
value=(lumelS-value)/BLUR_SIZE;
value=easineasout(value);
normalS=(normalS*value+average*(1-value));
normalS.normalize();
}
if (t<BLUR_SIZE)
{
tGood=true;
// Average the two normals
CVector average=normals[s][3];
average+=normals[s+1][3];
average/=2;
// Blend
float value=t+0.5f;
tFactor=BLUR_SIZE-value;
value/=BLUR_SIZE;
value=easineasout(value);
normalT=(normalT*value+average*(1-value));
normalT.normalize();
}
if (t>=lumelT-BLUR_SIZE)
{
tGood=true;
// Average the two normals
CVector average=normals[s][1];
average+=normals[s+1][1];
average/=2;
// Blend
float value=t+0.5f;
tFactor=BLUR_SIZE-(lumelT-value);
value=((lumelT)-value)/BLUR_SIZE;
value=easineasout(value);
normalT=(normalT*value+average*(1-value));
normalT.normalize();
}
// The smooth normal
CVector smoothNormal;
if ((sGood)&&(tGood))
{
if ((sFactor!=BLUR_SIZE)||(tFactor!=BLUR_SIZE))
smoothNormal=normalS*(BLUR_SIZE-tFactor)+normalT*(BLUR_SIZE-sFactor);
else
smoothNormal=normalS+normalT;
}
else if (sGood)
smoothNormal=normalS;
else
smoothNormal=normalT;
// Normalize it
smoothNormal.normalize();
// The pure normal
CVector purNormal=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT);
// Normalize the noisy normal
lumels[lumelIndex].Normal.normalize();
// Final normal
lumels[lumelIndex].Normal=lumels[lumelIndex].Normal-purNormal+smoothNormal;
lumels[lumelIndex].Normal.normalize ();
// *** Number of visit
uint visitedCount=visited[patch][lumelIndex];
// Some lumel have not been found in tesselation
//nlassert (visitedCount==2);
// If visited, renormalise other values
if (visitedCount)
{
// Normalise position
lumels[lumelIndex].S/=(float)visitedCount;
lumels[lumelIndex].T/=(float)visitedCount;
}
}
}
}
// ***************************************************************************
void CZoneLighter::computeTileFlagsOnly (CLandscape &landscape, CZone& output, uint zoneToLight, const CLightDesc& description,
std::vector<uint> &listZone)
{
// Zone to light
_ZoneToLight=zoneToLight;
// Landscape
_Landscape=&landscape;
// Zone count
uint zoneCount=listZone.size();
// For each zone
for (uint zone=0; zone<zoneCount; zone++)
{
// Get num patches
uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();
// Insert zone id
_ZoneId.insert (map<uint, uint>::value_type (listZone[zone], zone));
// For each patch
uint patch;
for (patch=0; patch<patchCount; patch++)
{
// Progress bar
progress ("Scan all patches", (float)patch/(float)patchCount);
// This is the zone to light ?
if (listZone[zone]==_ZoneToLight)
{
// unExclude all the patches from refine all
landscape.excludePatchFromRefineAll (listZone[zone], patch, false);
}
else
{
// Exclude all the patches from refine all
landscape.excludePatchFromRefineAll (listZone[zone], patch, true);
}
}
}
// *** Now tesselate this zone to max accuracy
// Setup the landscape
landscape.setThreshold (0);
landscape.setTileMaxSubdivision (0);
// Refine all
progress ("Refine landscape to maximum", 0.5f);
landscape.refineAll (CVector (0, 0, 0));
// Get tesselated faces
std::vector<const CTessFace*> leaves;
landscape.getTessellationLeaves(leaves);
// compute only the water states
if (_WaterShapes.size() != 0) // any water shape in this zone ?
{
/// make a quad grid of each water shape
makeQuadGridFromWaterShapes(landscape.getZone(_ZoneToLight)->getZoneBB().getAABBox());
/// check for each tile if it is above / below water
computeTileFlagsForPositionTowardWater(description, leaves);
}
else
{
setTileFlagsToDefault(leaves);
}
/// verify that the zonew and the zonel (output) are compatible
bool ok= true;
CZone &zonew= *(landscape.getZone(zoneToLight));
if(zonew.getNumPatchs() == output.getNumPatchs())
{
// verify for each patch that the tile array are same
for(uint i=0;i<(uint)zonew.getNumPatchs();i++)
{
const CPatch &p0= *const_cast<const CZone&>(zonew).getPatch(i);
const CPatch &p1= *const_cast<const CZone&>(output).getPatch(i);
if( p0.getOrderS()!=p1.getOrderS() || p0.getOrderT()!=p1.getOrderT() )
{
ok= false;
break;
}
}
}
else
ok= false;
// can't copy tile flags
if(!ok)
throw Exception("The input zonew, and ouput zonel are too different: not same patchs!!");
/// copy the tiles flags from the zone to light to the output zone
copyTileFlags(output, zonew);
}
// ***************************************************************************
CZoneLighter::CLightDesc::CLightDesc ()
{
SunDirection.set (1, 1, -1);
GridSize=512;
GridCellSize=4;
HeightfieldSize=200;
HeightfieldCellSize=20;
SkyContribution=true;
SkyIntensity=0.25;
ZBufferLandscapeSize = DEFAULT_ZBUFFER_LANDSCAPE_SIZE;
ZBufferObjectSize = DEFAULT_ZBUFFER_OBJECT_SIZE;
SoftShadowJitter = DEFAULT_JITTER;
SunDistance = DEFAULT_SUN_DISTANCE;
SunFOV = (float)DEFAULT_SUN_FOV;
SunCenter = DEFAULT_SUN_CENTER;
SunRadius = DEFAULT_SUN_RADIUS;
SoftShadowSamplesSqrt = DEFAULT_SUN_SRQT_SAMPLES;
}
// ***************************************************************************
void CZoneLighter::addLightableShape(IShape *shape, const NLMISC::CMatrix& MT)
{
CShapeInfo lsi;
lsi.MT = MT;
lsi.Shape = shape;
_LightableShapes.push_back(lsi);
}
// ***************************************************************************
bool CZoneLighter::isLightableShape(IShape &shape)
{
/// for now, the only shape that we lit are water shapes
if (dynamic_cast<CWaterShape *>(&shape) != NULL)
{
// check that this water surface has a diffuse map that is a CTextureFile (we must be able to save it !)
CWaterShape *ws = static_cast<CWaterShape *>(&shape);
const ITexture *tex = ws->getColorMap();
if (dynamic_cast<const CTextureFile *>(tex) != NULL)
{
return ws->isLightMappingEnabled();
}
}
return false;
}
// ***************************************************************************
void CZoneLighter::lightShapes(uint zoneID, const CLightDesc& description)
{
/// compute light for the lightable shapes in the given zone
if (_LightableShapes.size() == 0) return;
uint numShapePerThread = 1 + (_LightableShapes.size() / _ProcessCount);
uint currShapeIndex = 0;
uint process = 0;
_ProcessExited = 0;
_NumLightableShapesProcessed = 0;
progress("Processing lightable shapes", 0);
for (uint k = 0; k < _LightableShapes.size(); ++k, ++process)
{
uint lastShapeIndex = currShapeIndex + numShapePerThread;
lastShapeIndex = std::min((uint)_LightableShapes.size(), lastShapeIndex);
IThread *pThread = IThread::create (new CCalcLightableShapeRunnable(process, this, &description, &_LightableShapes, currShapeIndex, lastShapeIndex));
pThread->start();
currShapeIndex = lastShapeIndex;
}
/// wait for other process
while (_ProcessExited != _ProcessCount)
{
nlSleep (10);
}
}
// ***************************************************************************
void CZoneLighter::processLightableShapeCalc (uint process,
TShapeVect *shapesToLit,
uint firstShape,
uint lastShape,
const CLightDesc& description)
{
// for each lightable shape
for (uint k = firstShape; k < lastShape; ++k)
{
nlassert(isLightableShape(* (*shapesToLit)[k].Shape)); // make sure it is a lightable shape
lightSingleShape((*shapesToLit)[k], description, process);
}
}
// ***************************************************************************
void CZoneLighter::lightSingleShape(CShapeInfo &si, const CLightDesc& description, uint cpu)
{
/// we compute the lighting for one single shape
if (dynamic_cast<CWaterShape *>(si.Shape))
{
lightWater(* static_cast<CWaterShape *>(si.Shape), si.MT, description, cpu);
}
++_NumLightableShapesProcessed;
progress("Processing lightable shapes", (float) _NumLightableShapesProcessed / _LightableShapes.size());
return;
}
// ***************************************************************************
// utility function to get the directory of a fileName
static std::string getDir (const std::string& path)
{
char tmpPath[512];
strcpy (tmpPath, path.c_str());
char* slash=strrchr (tmpPath, '/');
if (!slash)
{
slash=strrchr (tmpPath, '\\');
}
if (!slash)
return "";
slash++;
*slash=0;
return tmpPath;
}
// ***************************************************************************
// utility function to get a file name fdrom a path
static std::string getName (const std::string& path)
{
std::string dir=getDir (path);
char tmpPath[512];
strcpy (tmpPath, path.c_str());
char *name=tmpPath;
nlassert (dir.length()<=strlen(tmpPath));
name+=dir.length();
char* point=strrchr (name, '.');
if (point)
*point=0;
return name;
}
// ***************************************************************************
// utility function to get the extension of a fileName
static std::string getExt (const std::string& path)
{
std::string dir = getDir (path);
std::string name = getName (path);
char tmpPath[512];
strcpy (tmpPath, path.c_str());
char *ext=tmpPath;
nlassert (dir.length()+name.length()<=strlen(tmpPath));
ext+=dir.length()+name.length();
return ext;
}
// ***************************************************************************
void CZoneLighter::lightWater(CWaterShape &ws, const CMatrix &MT, const CLightDesc& description, uint cpu)
{
try
{
/// get the diffuse map
CTextureFile *diffuseTex = NLMISC::safe_cast<CTextureFile *>(ws.getColorMap());
std::string texFileName = CPath::lookup(diffuseTex->getFileName());
diffuseTex->generate();
const uint width = diffuseTex->getWidth();
const uint height = diffuseTex->getHeight();
/// build a matrix to convert from water space to uv space
NLMISC::CMatrix worldSpaceToUVs;
NLMISC::CVector2f col0, col1, pos;
ws.getColorMapMat(col0, col1, pos);
worldSpaceToUVs.setRot(NLMISC::CVector(col0.x * width, col0.y * height, 0),
NLMISC::CVector(col1.x * width, col1.y * height, 0),
NLMISC::CVector::K);
worldSpaceToUVs.setPos(NLMISC::CVector(pos.x * width, pos.y * height, 0));
/// get min and max uvs
NLMISC::CPolygon p;
ws.getShapeInWorldSpace(p);
float minU, maxU;
float minV, maxV;
NLMISC::CVector uvs = worldSpaceToUVs * p.Vertices[0];
minU = maxU = uvs.x;
minV = maxV = uvs.y;
for (uint k = 1; k < (uint) p.getNumVertices(); ++k)
{
uvs = worldSpaceToUVs * p.Vertices[k];
minU = std::min(uvs.x, minU);
minV = std::min(uvs.y, minV);
maxU = std::max(uvs.x, maxU);
maxV = std::max(uvs.y, maxV);
}
sint iMinU = (sint) minU;
sint iMaxU = (sint) maxU;
sint iMinV = (sint) minV;
sint iMaxV = (sint) maxV;
NLMISC::clamp(iMinU, 0, (sint) width);
NLMISC::clamp(iMaxU, 0, (sint) width);
NLMISC::clamp(iMinV, 0, (sint) height);
NLMISC::clamp(iMaxV, 0, (sint) height);
// matrix to go from uv space to worldspace
NLMISC::CMatrix UVSpaceToWorldSpace = worldSpaceToUVs.inverted();
CObjectVector<uint8> &pixs8 = diffuseTex->getPixels();
NLMISC::CRGBA *rgbPixs = (NLMISC::CRGBA *) &pixs8[0];
/// raytrace each texel
for (sint x = iMinU; x < iMaxU; ++x)
{
for (sint y = iMinV; y < iMaxV; ++y)
{
float factor;
NLMISC::CVector pos = UVSpaceToWorldSpace * NLMISC::CVector( x + 0.5f, y + 0.5f, 0 )
+ description.WaterShadowBias * NLMISC::CVector::K;
if (description.Shadow)
{
factor = attenuation (pos, description);
}
else
{
factor = - NLMISC::CVector::K * description.SunDirection;
}
clamp(factor, 0.f, 1.f);
factor = factor * description.WaterDiffuse + description.WaterAmbient;
if (description.SkyContributionForWater)
{
factor += getSkyContribution(pos, NLMISC::CVector::K, description.SkyIntensity);
}
clamp(factor, 0.f, 1.f);
uint intensity = (uint8) (255 * factor);
NLMISC::CRGBA srcCol(intensity,
intensity,
intensity,
255);
if (!description.ModulateWaterColor)
{
rgbPixs[x + y * width] = srcCol;
}
else
{
NLMISC::CRGBA &col = rgbPixs[x + y * width];
col.modulateFromColor(col, srcCol);
}
}
}
/// now, save the result
if (getExt(texFileName) != ".tga")
{
nlwarning("Zone lighter : error when lighting a water surface : input bitmap is not a tga file");
}
else
{
try
{
COFile of;
of.open(texFileName);
diffuseTex->writeTGA(of, 24);
of.close();
}
catch (NLMISC::Exception &)
{
nlwarning("Zone lighter : while lighting a water shape, writing %s failed! ", texFileName.c_str());
}
}
}
catch(NLMISC::Exception &e)
{
nlwarning("Water shape lighting failed !");
nlwarning(e.what());
}
}
// ***********************************************************
void CZoneLighter::addWaterShape(CWaterShape *shape, const NLMISC::CMatrix &MT)
{
/// make sure it hasn't been inserted twice
CShapeInfo ci;
ci.Shape = shape;
ci.MT = MT;
_WaterShapes.push_back(ci);
}
// ***********************************************************
void CZoneLighter::makeQuadGridFromWaterShapes(NLMISC::CAABBox zoneBBox)
{
if (!_WaterShapes.size()) return;
NLMISC::CAABBox tmpBox;
/// the number of cells we want in the quad grid
const uint numCells = 16;
/// get the dimension
float width = zoneBBox.getMax().x - zoneBBox.getMin().x;
float height = zoneBBox.getMax().y - zoneBBox.getMin().y;
float dim = std::max(width, height);
/// init the quad grid
_WaterShapeQuadGrid.create(numCells, dim / numCells);
uint count = 0, totalCount = _WaterShapes.size();
/// now, insert all water shapes
for (TShapeVect::iterator it = _WaterShapes.begin(); it != _WaterShapes.end(); ++it, ++count)
{
/// get the current shape bbox in the world
it->Shape->getAABBox(tmpBox);
NLMISC::CAABBox currBB = NLMISC::CAABBox::transformAABBox(it->MT, tmpBox);
/// test if it intesect the zone bbox
if (zoneBBox.intersect(currBB))
{
_WaterShapeQuadGrid.insert(currBB.getMin(), currBB.getMax(), *it);
}
progress("Building quadtree from water surfaces", (float) count / totalCount);
}
/// free the vector of water shapes
NLMISC::contReset(_WaterShapes);
}
//==================================================================
/// a struct that helps us to know which tile we've processed
struct CTileOfPatch
{
uint8 TileId;
CPatch *Patch;
CTileOfPatch();
CTileOfPatch(uint8 tileId, CPatch *patch) : TileId(tileId), Patch(patch)
{
}
};
// ***************************************************************************
// ***************************************************************************
// Static point lights.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CZoneLighter::CPointLightRT::CPointLightRT()
{
RefCount= 0;
}
// ***************************************************************************
bool CZoneLighter::CPointLightRT::testRaytrace(const CVector &v)
{
CVector dummy;
if(!BSphere.include(v))
return false;
// If Ambient light, just skip
if(PointLight.getType()== CPointLight::AmbientLight)
return false;
// If SpotLight verify in angle radius.
if(PointLight.getType()== CPointLight::SpotLight)
{
float att= PointLight.computeLinearAttenuation(v);
if (att==0)
return false;
}
// Select in the cubeGrid
FaceCubeGrid.select(v);
// For all faces selected
while(!FaceCubeGrid.isEndSel())
{
const CTriangle *tri= FaceCubeGrid.getSel();
// If intersect, the point is occluded.
if( tri->Triangle.intersect(BSphere.Center, v, dummy, tri->getPlane()) )
return false;
// next
FaceCubeGrid.nextSel();
}
// Ok the point is visilbe from the light
return true;
}
// ***************************************************************************
void CZoneLighter::addStaticPointLight(const CPointLightNamed &pln)
{
// build the plRT.
CPointLightRT plRT;
plRT.PointLight= pln;
// compute plRT.OODeltaAttenuation
plRT.OODeltaAttenuation= pln.getAttenuationEnd() - pln.getAttenuationBegin();
if(plRT.OODeltaAttenuation <=0 )
plRT.OODeltaAttenuation= 0;
else
plRT.OODeltaAttenuation= 1.0f / plRT.OODeltaAttenuation;
// compute plRT.BSphere
plRT.BSphere.Center= pln.getPosition();
plRT.BSphere.Radius= pln.getAttenuationEnd();
// NB: FaceCubeGrid will be computed during light()
// add the plRT
_StaticPointLights.push_back(plRT);
}
// ***************************************************************************
void CZoneLighter::compilePointLightRT(uint gridSize, float gridCellSize, std::vector<CTriangle>& obstacles, bool doShadow)
{
uint i;
// Fill the quadGrid of Lights.
// ===========
_StaticPointLightQuadGrid.create(gridSize, gridCellSize);
for(i=0; i<_StaticPointLights.size();i++)
{
CPointLightRT &plRT= _StaticPointLights[i];
// Compute the bbox of the light
CAABBox bbox;
bbox.setCenter(plRT.BSphere.Center);
float hl= plRT.BSphere.Radius;
bbox.setHalfSize(CVector(hl,hl,hl));
// Insert the pointLight in the quadGrid.
_StaticPointLightQuadGrid.insert(bbox.getMin(), bbox.getMax(), &plRT);
}
// Append triangles to cubeGrid ??
if(doShadow)
{
// Point lights ?
if (!_StaticPointLights.empty ())
{
// For all obstacles, Fill a quadGrid.
// ===========
CQuadGrid<CTriangle*> obstacleGrid;
obstacleGrid.create(gridSize, gridCellSize);
uint size= obstacles.size();
for(i=0; i<size; i++)
{
// bbox of triangle
CAABBox bbox;
bbox.setCenter(obstacles[i].Triangle.V0);
bbox.extend(obstacles[i].Triangle.V1);
bbox.extend(obstacles[i].Triangle.V2);
// insert triangle in quadGrid.
obstacleGrid.insert(bbox.getMin(), bbox.getMax(), &obstacles[i]);
}
// For all PointLights, fill his CubeGrid
// ===========
for(i=0; i<_StaticPointLights.size();i++)
{
// progress
progress ("Compute Influences of PointLights", 0.5f*i / (float)(_StaticPointLights.size()-1));
CPointLightRT &plRT= _StaticPointLights[i];
// Create the cubeGrid
plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), NL3D_ZONE_LIGHTER_CUBE_GRID_SIZE);
// AmbiantLIghts: do nothing.
if(plRT.PointLight.getType()!=CPointLight::AmbientLight)
{
// Select only obstacle Faces around the light. Other are not useful
CAABBox bbox;
bbox.setCenter(plRT.PointLight.getPosition());
float hl= plRT.PointLight.getAttenuationEnd();
bbox.setHalfSize(CVector(hl,hl,hl));
obstacleGrid.select(bbox.getMin(), bbox.getMax());
// For all faces, fill the cubeGrid.
CQuadGrid<CTriangle*>::CIterator itObstacle;
itObstacle= obstacleGrid.begin();
while( itObstacle!=obstacleGrid.end() )
{
CTriangle &tri= *(*itObstacle);
// Triangle bounding box
CAABBox triBbox;
triBbox.setCenter (tri.Triangle.V0);
triBbox.extend (tri.Triangle.V1);
triBbox.extend (tri.Triangle.V2);
// Triangle in the light
if (triBbox.intersect (bbox))
{
// Test BackFace culling. Only faces which are BackFace the point light are inserted.
// This is to avoid AutoOccluding problems
if( tri.getPlane() * plRT.BSphere.Center < 0)
{
// Insert the triangle in the CubeGrid
plRT.FaceCubeGrid.insert( tri.Triangle, &tri);
}
}
itObstacle++;
}
}
// Compile the CubeGrid.
plRT.FaceCubeGrid.compile();
// And Reset RefCount.
plRT.RefCount= 0;
}
}
}
// else, just build empty grid
else
{
for(i=0; i<_StaticPointLights.size();i++)
{
// progress
progress ("Compute Influences of PointLights", 0.5f*i / (float)(_StaticPointLights.size()-1));
CPointLightRT &plRT= _StaticPointLights[i];
// Create a dummy empty cubeGrid => no rayTrace :)
plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), 4);
// Compile the CubeGrid.
plRT.FaceCubeGrid.compile();
// And Reset RefCount.
plRT.RefCount= 0;
}
}
}
// ***************************************************************************
bool CZoneLighter::CPredPointLightToPoint::operator() (CPointLightRT *pla, CPointLightRT *plb) const
{
float ra= (pla->BSphere.Center - Point).norm();
float rb= (plb->BSphere.Center - Point).norm();
float infA= (pla->PointLight.getAttenuationEnd() - ra) * pla->OODeltaAttenuation;
float infB= (plb->PointLight.getAttenuationEnd() - rb) * plb->OODeltaAttenuation;
// return which light impact the most.
// If same impact
if(infA==infB)
// return nearest
return ra < rb;
else
// return better impact
return infA > infB;
}
// ***************************************************************************
void CZoneLighter::processZonePointLightRT(vector<CPointLightNamed> &listPointLight)
{
uint i;
vector<CPointLightRT*> lightInfs;
lightInfs.reserve(1024);
// clear result list
listPointLight.clear();
// zoneToLight
CZone *zoneToLight= _Landscape->getZone(_ZoneToLight);
if(!zoneToLight)
return;
// Build patchForPLs
//===========
vector<CPatchForPL> patchForPLs;
patchForPLs.resize(_PatchInfo.size());
for(i=0; i<patchForPLs.size(); i++)
{
// Get OrderS/OrderT
patchForPLs[i].OrderS= _PatchInfo[i].OrderS;
patchForPLs[i].OrderT= _PatchInfo[i].OrderT;
// resize TileLightInfluences
uint w= patchForPLs[i].WidthTLI= patchForPLs[i].OrderS/2 +1 ;
uint h= patchForPLs[i].HeightTLI= patchForPLs[i].OrderT/2 +1;
patchForPLs[i].TileLightInfluences.resize(w*h);
}
// compute each TileLightInfluence
//===========
for(i=0; i<patchForPLs.size(); i++)
{
// progress
progress ("Compute Influences of PointLights", 0.5f + 0.5f*i / (float)patchForPLs.size());
CPatchForPL &pfpl= patchForPLs[i];
const CPatch *patch= const_cast<const CZone*>(zoneToLight)->getPatch(i);
uint x, y;
for(y= 0; y<pfpl.HeightTLI; y++)
{
for(x= 0; x<pfpl.WidthTLI; x++)
{
// compute the point and normal (normalized) where the TLI lies.
//---------
CVector pos, normal;
float s, t;
s= (float)x / (pfpl.WidthTLI-1);
t= (float)y / (pfpl.HeightTLI-1);
// Compute the Vertex, with Noise information (important for accurate raytracing).
pos= patch->computeVertex(s, t);
// Use UnNoised normal from BezierPatch, because the lighting does not need to be so precise.
CBezierPatch *bp= patch->unpackIntoCache();
normal= bp->evalNormal(s, t);
// Compute Which light influences him.
//---------
lightInfs.clear();
// Search possible lights around the position.
_StaticPointLightQuadGrid.select(pos, pos);
// For all of them, get the ones which touch this point.
CQuadGrid<CPointLightRT*>::CIterator it= _StaticPointLightQuadGrid.begin();
while(it != _StaticPointLightQuadGrid.end())
{
CPointLightRT *pl= *it;
// a light influence a TLI only if this one is FrontFaced to the light !!
if( ( pl->BSphere.Center - pos ) * normal > 0)
{
// Add 5cm else it fails in some case where ( pl->BSphere.Center - pos ) * normal is
// nearly 0 and the point should be occluded.
const float deltaY= 0.05f;
CVector posToRT= pos + normal * deltaY;
// Test if really in the radius of the light, if no occlusion, and if in SpotAngle
if( pl->testRaytrace(posToRT) )
{
// Ok, add the light to the lights which influence the TLI
lightInfs.push_back(pl);
}
}
// next
it++;
}
// Choose the Best ones.
//---------
CPredPointLightToPoint predPLTP;
predPLTP.Point= pos;
// sort.
sort(lightInfs.begin(), lightInfs.end(), predPLTP);
// truncate.
lightInfs.resize( min((uint)lightInfs.size(), (uint)CTileLightInfluence::NumLightPerCorner) );
// For each of them, fill TLI
//---------
CTileLightInfUnpack tli;
uint lightInfId;
for(lightInfId=0; lightInfId<lightInfs.size(); lightInfId++)
{
CPointLightRT *pl= lightInfs[lightInfId];
// copy light.
tli.Light[lightInfId]= pl;
// Compute light Diffuse factor.
CVector dir= pl->BSphere.Center - pos;
dir.normalize();
tli.LightFactor[lightInfId]= dir * normal;
clamp(tli.LightFactor[lightInfId], 0.f, 1.f);
// modulate by light attenuation.
tli.LightFactor[lightInfId]*= pl->PointLight.computeLinearAttenuation(pos);
// Inc RefCount of the light.
pl->RefCount++;
}
// Reset any empty slot to NULL.
for(; lightInfId<CTileLightInfluence::NumLightPerCorner; lightInfId++)
{
tli.Light[lightInfId]= NULL;
}
// Set TLI in patch.
//---------
pfpl.TileLightInfluences[y*pfpl.WidthTLI + x]= tli;
}
}
}
// compress and setup _PatchInfo with compressed data.
//===========
uint plId= 0;
// Process each pointLights
for(i=0; i<_StaticPointLights.size(); i++)
{
CPointLightRT &plRT= _StaticPointLights[i];
// If this light is used.
if(plRT.RefCount > 0)
{
// Must Copy it into Zone.
listPointLight.push_back(plRT.PointLight);
plRT.DstId= plId++;
// If index >= 255, too many lights (NB: => because 255 is a NULL code).
if(plId>=0xFF)
{
throw Exception("Too many Static Point Lights influence the zone!!");
}
}
}
// For each patch, compress TLI in PatchInfo.
for(i=0; i<patchForPLs.size(); i++)
{
CPatchForPL &pfpl= patchForPLs[i];
CPatchInfo &pInfo= _PatchInfo[i];
uint w= pfpl.WidthTLI;
uint h= pfpl.HeightTLI;
// Fill pInfo.TileLightInfluences
pInfo.TileLightInfluences.resize(w*h);
uint x, y;
for(y= 0; y<h; y++)
{
for(x= 0; x<w; x++)
{
uint tliId= y*w + x;
// For all light slot
for(uint lightId= 0; lightId<CTileLightInfluence::NumLightPerCorner; lightId++)
{
CTileLightInfUnpack &tliSrc= pfpl.TileLightInfluences[tliId];
CTileLightInfluence &tliDst= pInfo.TileLightInfluences[tliId];
if(tliSrc.Light[lightId] == NULL)
{
// Mark as unused.
tliDst.Light[lightId]= 0xFF;
}
else
{
// Get index.
tliDst.Light[lightId]= tliSrc.Light[lightId]->DstId;
// Get Diffuse Factor.
tliDst.setDiffuseLightFactor(lightId, (uint8)(tliSrc.LightFactor[lightId]*255));
}
}
}
}
}
}
// ***********************************************************
// ***********************************************************
// TileFlagsForPositionTowardWater
// ***********************************************************
// ***********************************************************
//==================================================================
/// for map insertion of CTileOfPatch structs
static inline bool operator < (const CTileOfPatch &lhs, const CTileOfPatch &rhs)
{
return lhs.Patch == rhs.Patch ?
lhs.TileId < rhs.TileId :
lhs.Patch < rhs.Patch;
};
/// A set of tiles from patch and their bbox
typedef std::map<CTileOfPatch, NLMISC::CAABBox> TTileOfPatchMap;
// ***********************************************************
void CZoneLighter::computeTileFlagsForPositionTowardWater(const CLightDesc &lightDesc,
std::vector<const CTessFace*> &tessFaces
)
{
uint numTileAbove = 0;
uint numTileBelow = 0;
uint numTileIntersect = 0;
/// the tiles that we have setupped so far...
TTileOfPatchMap tiles;
///////////////////////////////////////////
// First, build the bbox for all tiles //
///////////////////////////////////////////
uint triCount = 0, totalTriCount = tessFaces.size();
nlinfo("Dealing with %d tessFaces", tessFaces.size());
for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it, ++triCount)
{
/// does the face belong to the zone to light ?
if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue;
/// if the tile flags say that micro vegetation is disabled, just skip that
if ((*it)->Patch->Tiles[(*it)->TileId].getVegetableState() == CTileElement::VegetableDisabled)
continue;
CTileOfPatch top((*it)->TileId, (*it)->Patch);
TTileOfPatchMap::iterator tileIt = tiles.find(top);
/// test whether we've seen face(s) from this tile before
if (tileIt == tiles.end()) // first time ?
{
/// build a bbox for this face
NLMISC::CAABBox b;
b.setMinMax((*it)->VBase->EndPos, (*it)->VLeft->EndPos);
b.extend((*it)->VRight->EndPos);
b.extend(b.getMax() + lightDesc.VegetableHeight * NLMISC::CVector::K); // adds vegetable height
tiles[top] = b;
}
else // extends the bbox with the given face
{
NLMISC::CAABBox &b = tileIt->second;
b.extend((*it)->VBase->EndPos);
b.extend((*it)->VRight->EndPos);
b.extend((*it)->VLeft->EndPos);
}
if ((triCount % 100) == 0)
{
progress("Building bbox from tiles", (float) triCount / totalTriCount);
}
}
progress("Building bbox from tiles", 1.f);
////////////////////////////////////////////////////
// Now, check each tile bbox against water shapes //
////////////////////////////////////////////////////
NLMISC::CPolygon waterPoly;
NLMISC::CPolygon2D tilePoly;
tilePoly.Vertices.resize(4);
uint tileCount = 0, totalTileCount = tiles.size();
for (TTileOfPatchMap::iterator tileIt = tiles.begin(); tileIt != tiles.end(); ++tileIt, ++tileCount)
{
const NLMISC::CVector v0 = tileIt->second.getMin();
const NLMISC::CVector v1 = tileIt->second.getMax();
/// build a top view from the bbox
tilePoly.Vertices[0].set(v0.x, v0.y);
tilePoly.Vertices[1].set(v1.x, v0.y);
tilePoly.Vertices[2].set(v1.x, v1.y);
tilePoly.Vertices[3].set(v0.x, v1.y);
/// Select the candidate water shape from the quad grid
_WaterShapeQuadGrid.clearSelection();
_WaterShapeQuadGrid.select(tileIt->second.getMin(), tileIt->second.getMax());
CTileElement &te = tileIt->first.Patch->Tiles[tileIt->first.TileId]; // alias to the current tile element
/// test more accurate intersection for each water shape
TWaterShapeQuadGrid::CIterator qgIt;
for (qgIt = _WaterShapeQuadGrid.begin(); qgIt != _WaterShapeQuadGrid.end(); ++qgIt)
{
CWaterShape *waterShape= safe_cast<CWaterShape*>((*qgIt).Shape);
waterShape->getShapeInWorldSpace(waterPoly, (*qgIt).MT);
NLMISC::CPolygon2D poly(waterPoly);
if (poly.intersect(tilePoly)) // above or below a water surface ?
{
/// height of water
float waterHeight = waterPoly.Vertices[0].z;
if (v1.z < waterHeight)
{
// below
te.setVegetableState(CTileElement::UnderWater);
//nlassert(te.getVegetableState() == CTileElement::UnderWater);
++ numTileBelow;
}
else if (v0. z > waterHeight)
{
// above
te.setVegetableState(CTileElement::AboveWater);
//nlassert(te.getVegetableState() == CTileElement::AboveWater);
++ numTileAbove;
}
else
{
// intersect water
te.setVegetableState(CTileElement::IntersectWater);
//nlassert(te.getVegetableState() == CTileElement::IntersectWater);
++ numTileIntersect;
}
break;
}
}
if (qgIt == _WaterShapeQuadGrid.end()) // no intersection found ? if yes it's above water
{
te.setVegetableState(CTileElement::AboveWater);
//nlassert(te.getVegetableState() == CTileElement::AboveWater);
++ numTileAbove;
}
if ((tileCount % 50) == 0)
{
progress("Computing tile position towards water", (float) tileCount / totalTileCount);
}
}
progress("Computing tile position towards water", 1.f);
nlinfo(" %d tiles are above water.", numTileAbove);
nlinfo(" %d tiles are below water.", numTileBelow);
nlinfo(" %d tiles intersect water.", numTileIntersect);
/// delete the quadgrid now
NLMISC::contReset(_WaterShapeQuadGrid);
}
// ***********************************************************
void CZoneLighter::setTileFlagsToDefault(std::vector<const CTessFace*> &tessFaces)
{
/// We may setup a tile several time, but this doesn't matter here...
for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it)
{
if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue;
CTileElement &te = (*it)->Patch->Tiles[(*it)->TileId];
if (te.getVegetableState() != CTileElement::VegetableDisabled)
{
te.setVegetableState(CTileElement::AboveWater);
}
}
}
// ***********************************************************
uint CZoneLighter::getAPatch (uint process)
{
// Accessor
CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed);
// Current index
uint index = _LastPatchComputed[process];
uint firstIndex = index;
if (access.value().size() == 0)
// no more patches
return 0xffffffff;
while (access.value()[index])
{
// Next patch
index++;
// Last patch ?
if (index == _PatchInfo.size())
index = 0;
// First ?
if (firstIndex == index)
// no more patches
return 0xffffffff;
}
// Visited
access.value()[index] = true;
// Last index
_LastPatchComputed[process] = index;
_NumberOfPatchComputed++;
// Return the index
return index;
}
// ***********************************************************
float CZoneLighter::attenuation (const CVector &pos, const CZoneLighter::CLightDesc &description)
{
// Clipped ?
// *** Landscape attenuation
// Current value
float averageAttenuation = 0;
float randomSum = 0;
// For each sample
uint sample;
const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt;
for (sample=0; sample<samples; sample++)
{
// The zbuffer
CZBuffer &zbuffer = _ZBufferLandscape[sample];
// Get position in z buffer
CVector zPos;
transformVectorToZBuffer (zbuffer, pos, zPos);
// Get the z
float random = (float)_Random.rand () * description.SoftShadowJitter + _Random.RandMax * (1.f - description.SoftShadowJitter);
averageAttenuation += random * testZPercentageCloserFilter (zPos.x-(float)zbuffer.LocalZBufferXMin, zPos.y-(float)zbuffer.LocalZBufferYMin, zPos.z, zbuffer, description, _ZBufferOverflow);
randomSum += random;
}
// Average landscape attenuation
averageAttenuation /= randomSum;
// *** Attenuation in the object zbuffer
// Get position in z buffer
CVector zPos;
transformVectorToZBuffer (_ZBufferObject, pos, zPos);
const float objectAttenuation = testZPercentageCloserFilter (zPos.x-(float)_ZBufferObject.LocalZBufferXMin, zPos.y-(float)_ZBufferObject.LocalZBufferYMin, zPos.z, _ZBufferObject, description, _ZBufferOverflow);
// *** Return the min of the both
return std::min (objectAttenuation, averageAttenuation);
}
// ***********************************************************
Reference in a new issue Copy permalink