724 lines
22 KiB
C++
724 lines
22 KiB
C++
|
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
||
|
|
// 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 "stdpch.h"
|
||
|
|
#include "landscape_poly_drawer.h"
|
||
|
|
|
||
|
|
// 3D Interfaces
|
||
|
|
#include "nel/3d/u_driver.h"
|
||
|
|
#include "nel/3d/u_scene.h"
|
||
|
|
#include "nel/3d/u_landscape.h"
|
||
|
|
|
||
|
|
// 3d
|
||
|
|
#include "nel/3d/zone.h"
|
||
|
|
#include "nel/3d/driver_user.h"
|
||
|
|
|
||
|
|
// client
|
||
|
|
#include "decal.h"
|
||
|
|
|
||
|
|
using namespace NLMISC;
|
||
|
|
using namespace NL3D;
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
|
||
|
|
// EXTERN
|
||
|
|
extern UDriver *Driver;
|
||
|
|
extern UScene *Scene;
|
||
|
|
extern UMaterial GenericMat;
|
||
|
|
extern ULandscape *Landscape;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
//---------------------------------------- CInitStencil -----------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CInitStencil::init()
|
||
|
|
{
|
||
|
|
// set ILandscapePolyDrawingCallback attribute of current scene
|
||
|
|
Scene->setLandscapePolyDrawingCallback(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CInitStencil::beginPolyDrawing()
|
||
|
|
{
|
||
|
|
// The eighth bit will be written with a 1 during next render (landscape)
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::keep, UDriver::replace);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CInitStencil::endPolyDrawing()
|
||
|
|
{
|
||
|
|
// The eighth bit will be written with a 0 during next render (veget,...)
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::keep, UDriver::zero);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
//---------------------------------- CLandscapePolyDrawer ---------------------------------------------------
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
CLandscapePolyDrawer::CLandscapePolyDrawer()
|
||
|
|
{
|
||
|
|
// set ILandscapePolyDrawingCallback attribute of current scene to modify stencil operation
|
||
|
|
// from NEL classes with callbacks.
|
||
|
|
_InitStencil = new CInitStencil();
|
||
|
|
_InitStencil->init();
|
||
|
|
|
||
|
|
// shadow rectangle
|
||
|
|
_Shadow.V0 = CVector(0.0, 0.0, 0.0);
|
||
|
|
_Shadow.V1 = CVector(1.0, 0.0, 0.0);
|
||
|
|
_Shadow.V2 = CVector(1.0, 1.0, 0.0);
|
||
|
|
_Shadow.V3 = CVector(0.0, 1.0, 0.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::initLandscapePolyDrawingCallback()
|
||
|
|
{
|
||
|
|
// set ILandscapePolyDrawingCallback attribute of current scene to modify stencil operation
|
||
|
|
// from NEL classes with callbacks.
|
||
|
|
nlassert(_InitStencil);
|
||
|
|
_InitStencil->init();
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
CLandscapePolyDrawer::~CLandscapePolyDrawer()
|
||
|
|
{
|
||
|
|
delete _InitStencil;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::addPoly(const NLMISC::CPolygon2D &poly,
|
||
|
|
const NLMISC::CRGBA & color, const NLMISC::CAABBox & bBox)
|
||
|
|
{
|
||
|
|
nlassert(!poly.Vertices.empty());
|
||
|
|
_Polygons.push_back(poly);
|
||
|
|
_PolyColor.push_back(color);
|
||
|
|
_BBoxes.push_back(bBox);
|
||
|
|
|
||
|
|
buildShadowVolume((uint)_Polygons.size());
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::beginRenderLandscapePolyPart()
|
||
|
|
{
|
||
|
|
// activation of stencil test
|
||
|
|
Driver->enableStencilTest(true);
|
||
|
|
|
||
|
|
Driver->stencilFunc(UDriver::always, 128, 0xff);
|
||
|
|
|
||
|
|
// the eighth bit will be written with a 0 during next render to mark stencil buffer
|
||
|
|
// parts which will support Shadow Volume algorithm (landscape).
|
||
|
|
// When stencil operation will be modify with "replace" operation, the eighth bit will be written
|
||
|
|
// with a 1 (vegeation, shadow...)
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::keep, UDriver::zero);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
inline void createFace(CVector * face, const vector<CVector> & vertices, uint v1,
|
||
|
|
uint v2, uint v3, uint v4)
|
||
|
|
{
|
||
|
|
face[0] = vertices[v1];
|
||
|
|
face[1] = vertices[v2];
|
||
|
|
face[2] = vertices[v3];
|
||
|
|
face[3] = vertices[v4];
|
||
|
|
}
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::setScissor(uint polyId)
|
||
|
|
{
|
||
|
|
// vector of bounding box vertices
|
||
|
|
const CAABBox & bBox = _BBoxes[polyId];
|
||
|
|
const CVector& center = bBox.getCenter();
|
||
|
|
const CVector& halfSize = bBox.getHalfSize();
|
||
|
|
|
||
|
|
vector<CVector> vertices(8);
|
||
|
|
vertices[0] = CVector(center.x-halfSize.x, center.y+halfSize.y, center.z+halfSize.z);
|
||
|
|
vertices[1] = CVector(center.x+halfSize.x, center.y+halfSize.y, center.z+halfSize.z);
|
||
|
|
vertices[2] = CVector(center.x+halfSize.x, center.y-halfSize.y, center.z+halfSize.z);
|
||
|
|
vertices[3] = CVector(center.x-halfSize.x, center.y-halfSize.y, center.z+halfSize.z);
|
||
|
|
vertices[4] = CVector(center.x-halfSize.x, center.y+halfSize.y, center.z-halfSize.z);
|
||
|
|
vertices[5] = CVector(center.x+halfSize.x, center.y+halfSize.y, center.z-halfSize.z);
|
||
|
|
vertices[6] = CVector(center.x+halfSize.x, center.y-halfSize.y, center.z-halfSize.z);
|
||
|
|
vertices[7] = CVector(center.x-halfSize.x, center.y-halfSize.y, center.z-halfSize.z);
|
||
|
|
|
||
|
|
// transform each point to obtain vertices coordinates in camera location
|
||
|
|
CMatrix transformMatrix = Scene->getCam().getMatrix();
|
||
|
|
transformMatrix.invert();
|
||
|
|
for(uint i=0; i<8; i++)
|
||
|
|
{
|
||
|
|
CVector & point = vertices[i];
|
||
|
|
point = transformMatrix.mulPoint(point);
|
||
|
|
}
|
||
|
|
|
||
|
|
// clip bounding box faces
|
||
|
|
CVector faces[6][4];
|
||
|
|
createFace(faces[0], vertices, 3, 2, 1, 0);
|
||
|
|
createFace(faces[1], vertices, 7, 6, 5, 4);
|
||
|
|
createFace(faces[2], vertices, 0, 1, 5, 4);
|
||
|
|
createFace(faces[3], vertices, 7, 6, 2, 3);
|
||
|
|
createFace(faces[4], vertices, 2, 6, 5, 1);
|
||
|
|
createFace(faces[5], vertices, 7, 3, 0, 4);
|
||
|
|
|
||
|
|
// "near" plane of current frustum
|
||
|
|
CPlane nearPlane;
|
||
|
|
nearPlane.make(CVector(0, 1, 0), CVector(0, Driver->getFrustum().Near, 0));
|
||
|
|
CVector out[10];
|
||
|
|
|
||
|
|
_FiniteFrustum = Driver->getFrustum();
|
||
|
|
CVector2f rectMax(0,0), rectMin(0,0);
|
||
|
|
|
||
|
|
// for each face, we research its intersection points with "near" plane (if exist)
|
||
|
|
for(uint f=0; f<6; f++)
|
||
|
|
{
|
||
|
|
uint outNb = nearPlane.clipPolygonFront(faces[f], out, 4);
|
||
|
|
|
||
|
|
// if intersection points exist, we project them in windows coordinates to recover
|
||
|
|
// scissor rectangle
|
||
|
|
if(outNb!=0)
|
||
|
|
{
|
||
|
|
for(uint v=0; v<outNb; v++)
|
||
|
|
{
|
||
|
|
CVector & point = out[v];
|
||
|
|
//project
|
||
|
|
point = _FiniteFrustum.project(point);
|
||
|
|
//clamp
|
||
|
|
NLMISC::clamp(point.x, 0, 1);
|
||
|
|
NLMISC::clamp(point.y, 0, 1);
|
||
|
|
|
||
|
|
// search for bounding rectangle of scissor test
|
||
|
|
if(f==0 && v==0)
|
||
|
|
{
|
||
|
|
rectMax = rectMin = point;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rectMax.x = std::max(rectMax.x, point.x);
|
||
|
|
rectMax.y = std::max(rectMax.y, point.y);
|
||
|
|
rectMin.x = std::min(rectMin.x, point.x);
|
||
|
|
rectMin.y = std::min(rectMin.y, point.y);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CScissor scissor(rectMin.x, rectMin.y, rectMax.x - rectMin.x, rectMax.y - rectMin.y);
|
||
|
|
Driver->setScissor(scissor);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::renderLandscapePolyPart()
|
||
|
|
{
|
||
|
|
uint i;
|
||
|
|
|
||
|
|
UCamera cam = Scene->getCam();
|
||
|
|
Driver->setMatrixMode3D(cam);
|
||
|
|
|
||
|
|
CViewport oldViewPort = Driver->getViewport();
|
||
|
|
|
||
|
|
Driver->setViewport(Scene->getViewport());
|
||
|
|
|
||
|
|
// get initial values of depth range
|
||
|
|
float depthRangeMin;
|
||
|
|
Driver->getDepthRange(depthRangeMin, _MaxDepthRange);
|
||
|
|
|
||
|
|
// get original (finite) frustum
|
||
|
|
_FiniteFrustum = Driver->getFrustum();
|
||
|
|
|
||
|
|
// we can write in stencil buffer only the last 7 bits.
|
||
|
|
// The eighth bit mustn't be written because it indicates if a part of stencil buffer
|
||
|
|
// can support shadow volume algorithm.
|
||
|
|
Driver->stencilMask(0x7f);
|
||
|
|
|
||
|
|
for(i=1; i<=_Polygons.size(); i++)
|
||
|
|
{
|
||
|
|
// calculate and set scissor rectangle to optimize algorithm.
|
||
|
|
setScissor(i-1);
|
||
|
|
|
||
|
|
// disable color buffer update
|
||
|
|
Driver->setColorMask(false, false, false, false);
|
||
|
|
Scene->enableLightingSystem(false);
|
||
|
|
|
||
|
|
// disable Z buffer update
|
||
|
|
GenericMat.setZWrite(false);
|
||
|
|
|
||
|
|
// ZFAIL algorithm
|
||
|
|
{
|
||
|
|
// test and write only if eighth bit is a 1 (landscape).
|
||
|
|
Driver->stencilFunc(UDriver::notequal, 0, 0x80);
|
||
|
|
|
||
|
|
// display of shadow volumes in two passes
|
||
|
|
|
||
|
|
GenericMat.setDoubleSided(false);
|
||
|
|
|
||
|
|
// render the shadow volume back faces and increment the stencil buffer
|
||
|
|
// when the depth test fails
|
||
|
|
Driver->setCullMode(UDriver::CW);
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::incr, UDriver::keep);
|
||
|
|
drawShadowVolume(i, true);
|
||
|
|
|
||
|
|
// render the shadow volume front faces and decrement the stencil buffer
|
||
|
|
// when the depth test fails
|
||
|
|
Driver->setCullMode(UDriver::CCW);
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::decr, UDriver::keep);
|
||
|
|
drawShadowVolume(i, false);
|
||
|
|
|
||
|
|
GenericMat.setDoubleSided(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// enable color and Z Buffer updates
|
||
|
|
Driver->setColorMask(true, true, true, true);
|
||
|
|
GenericMat.setZWrite(true);
|
||
|
|
|
||
|
|
// enable light
|
||
|
|
Scene->enableLightingSystem(true);
|
||
|
|
|
||
|
|
// render of the polygon : render of a rectangle whith polygon color.
|
||
|
|
// It's renderer only if stencil buffer is different to 0 on seven last bits
|
||
|
|
Driver->stencilFunc(UDriver::notequal, 0, 0x7f);
|
||
|
|
|
||
|
|
// if stencil buffer is different to 0 (polygon), value must be
|
||
|
|
// replace by 0 (seven last bits).
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::keep, UDriver::replace);
|
||
|
|
drawPolygon(i);
|
||
|
|
|
||
|
|
// reset neutral values
|
||
|
|
Driver->stencilOp(UDriver::keep, UDriver::keep, UDriver::keep);
|
||
|
|
Driver->setScissor(CScissor(0, 0, 1, 1));
|
||
|
|
}
|
||
|
|
|
||
|
|
// render decals on landscape only
|
||
|
|
Driver->stencilFunc(UDriver::equal, 0x80, 0x80);
|
||
|
|
|
||
|
|
// call to render the decals just before the projected polygons on landscape
|
||
|
|
CDecalRenderList::getInstance().renderAllDecals();
|
||
|
|
|
||
|
|
// disable stencil test
|
||
|
|
Driver->enableStencilTest(false);
|
||
|
|
Driver->stencilMask(0xff);
|
||
|
|
Driver->stencilFunc(UDriver::always, 0, 0xff);
|
||
|
|
|
||
|
|
// reset viewport
|
||
|
|
Driver->setViewport(oldViewPort);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void
|
||
|
|
CLandscapePolyDrawer::infiniteFrustum()
|
||
|
|
{
|
||
|
|
// setup new values of depth range
|
||
|
|
Driver->setDepthRange(0.0, 1.0);
|
||
|
|
|
||
|
|
// znear and zfar initial values
|
||
|
|
float znear, zfar;
|
||
|
|
znear = _FiniteFrustum.Near;
|
||
|
|
zfar = _FiniteFrustum.Far;
|
||
|
|
|
||
|
|
// initial projection matrix
|
||
|
|
CMatrix frustumMatrix = Driver->getFrustumMatrix();
|
||
|
|
|
||
|
|
// epsilon depends from OpenGL or Direct3D use
|
||
|
|
double factor = Driver->getClipSpaceZMin() == -1.f ? 2 : 1;
|
||
|
|
double epsilon = factor*(1 - _MaxDepthRange*(zfar/(zfar - znear)));
|
||
|
|
|
||
|
|
// update of coefficients to obtain "robust" infinite frustum,
|
||
|
|
// and join depth range used in main scen display
|
||
|
|
// OpenGL
|
||
|
|
if(factor == 2)
|
||
|
|
{
|
||
|
|
frustumMatrix.setCoefficient((float)(epsilon-1), 2, 2);
|
||
|
|
frustumMatrix.setCoefficient((float)(znear*(epsilon-2)), 2, 3);
|
||
|
|
}
|
||
|
|
// Direct3D
|
||
|
|
else
|
||
|
|
{
|
||
|
|
frustumMatrix.setCoefficient((float)(1-epsilon), 2, 2);
|
||
|
|
frustumMatrix.setCoefficient((float)(znear*(epsilon-1)), 3, 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
// initial projection matrix
|
||
|
|
Driver->setFrustumMatrix(frustumMatrix);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void
|
||
|
|
CLandscapePolyDrawer::finiteFrustum()
|
||
|
|
{
|
||
|
|
// depth range
|
||
|
|
Driver->setDepthRange(0.0, _MaxDepthRange);
|
||
|
|
|
||
|
|
// projection matrix
|
||
|
|
Driver->setFrustum(_FiniteFrustum);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::buildShadowVolume(uint poly)
|
||
|
|
{
|
||
|
|
uint i, v1, v2, v3, v4;
|
||
|
|
CVertexBuffer vb;
|
||
|
|
CIndexBuffer ib;
|
||
|
|
CVector2f barycenter(0, 0);
|
||
|
|
const CPolygon2D & polygon = _Polygons[poly-1];
|
||
|
|
uint verticesNb = (uint)polygon.Vertices.size();
|
||
|
|
|
||
|
|
// barycenter polygon
|
||
|
|
for(i=0; i<verticesNb; i++)
|
||
|
|
{
|
||
|
|
barycenter += polygon.Vertices[i];
|
||
|
|
}
|
||
|
|
barycenter = barycenter/((float)verticesNb);
|
||
|
|
_Barycenters.push_back(barycenter);
|
||
|
|
|
||
|
|
// vertex buffer initialization.
|
||
|
|
// vertices coordinates aren't calculated immediately but in drawShadowVolume method,
|
||
|
|
// because they are calculated in camera location.
|
||
|
|
vb.setVertexFormat(CVertexBuffer::PositionFlag);
|
||
|
|
vb.setNumVertices(2*verticesNb + 2);
|
||
|
|
{
|
||
|
|
CVertexBufferReadWrite vba;
|
||
|
|
vb.lock(vba);
|
||
|
|
|
||
|
|
for(i=0; i<2*verticesNb + 2; i++)
|
||
|
|
{
|
||
|
|
vba.setVertexCoord(i, CVector(0.0, 0.0, 0.0));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_PolyVB.push_back(vb);
|
||
|
|
|
||
|
|
// index buffer initialization.
|
||
|
|
int index = 0;
|
||
|
|
ib.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
|
||
|
|
ib.setNumIndexes(12*verticesNb);
|
||
|
|
{
|
||
|
|
CIndexBufferReadWrite iba;
|
||
|
|
ib.lock (iba);
|
||
|
|
|
||
|
|
// near cap
|
||
|
|
for(v1=1; v1<=verticesNb; v1++)
|
||
|
|
{
|
||
|
|
v2 = v1+1;
|
||
|
|
if(v2 == verticesNb+1)
|
||
|
|
{
|
||
|
|
v2 = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
iba.setTri(index, v1, v2, 0);
|
||
|
|
index += 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
// far cap
|
||
|
|
for(v1=verticesNb+2; v1<=2*verticesNb+1; v1++)
|
||
|
|
{
|
||
|
|
v2 = v1+1;
|
||
|
|
if(v2 == 2*verticesNb+2)
|
||
|
|
{
|
||
|
|
v2 = verticesNb+2;
|
||
|
|
}
|
||
|
|
|
||
|
|
iba.setTri(index, v2, v1, verticesNb+1);
|
||
|
|
index += 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
// surrounding faces
|
||
|
|
for(v1=1; v1<=verticesNb; v1++)
|
||
|
|
{
|
||
|
|
v3 = v1+verticesNb+1;
|
||
|
|
|
||
|
|
v2 = v1+1;
|
||
|
|
if(v2 == verticesNb+1)
|
||
|
|
{
|
||
|
|
v2 = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
v4 = v3+1;
|
||
|
|
if(v4 == 2*verticesNb+2)
|
||
|
|
{
|
||
|
|
v4 = verticesNb+2;
|
||
|
|
}
|
||
|
|
|
||
|
|
// first triangle
|
||
|
|
iba.setTri(index, v2, v1, v3);
|
||
|
|
index += 3;
|
||
|
|
|
||
|
|
// second triangle
|
||
|
|
iba.setTri(index, v2, v3, v4);
|
||
|
|
index += 3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
_PolyIB.push_back(ib);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::drawShadowVolume(uint poly, bool firstPass)
|
||
|
|
{
|
||
|
|
if(firstPass)
|
||
|
|
{
|
||
|
|
// render shadow volume in camera location, in order to minimize
|
||
|
|
// polygon coordinates
|
||
|
|
CVertexBuffer & vb = _PolyVB[poly-1];
|
||
|
|
const CPolygon2D & polygon = _Polygons[poly-1];
|
||
|
|
const CVector2f & barycenter = _Barycenters[poly-1];
|
||
|
|
uint verticesNb = (uint)polygon.Vertices.size();
|
||
|
|
|
||
|
|
uint i;
|
||
|
|
CVector2f vertex;
|
||
|
|
CVector * vertexVB = NULL;
|
||
|
|
const CVector cameraPos = Scene->getCam().getPos();
|
||
|
|
|
||
|
|
float height = 2000.0;
|
||
|
|
{
|
||
|
|
CVertexBufferReadWrite vba;
|
||
|
|
vb.lock(vba);
|
||
|
|
|
||
|
|
// top vertices
|
||
|
|
vertexVB = vba.getVertexCoordPointer(0);
|
||
|
|
*vertexVB = CVector(barycenter.x, barycenter.y, height) - cameraPos;
|
||
|
|
|
||
|
|
for(i=0; i<verticesNb; i++)
|
||
|
|
{
|
||
|
|
vertex = polygon.Vertices[i];
|
||
|
|
vertexVB = vba.getVertexCoordPointer(i+1);
|
||
|
|
*vertexVB = CVector(vertex.x, vertex.y, height) - cameraPos;
|
||
|
|
}
|
||
|
|
|
||
|
|
// bottom vertices
|
||
|
|
vertexVB = vba.getVertexCoordPointer(verticesNb+1);
|
||
|
|
*vertexVB = CVector(barycenter.x, barycenter.y, -height) - cameraPos;
|
||
|
|
|
||
|
|
for(i=0; i<verticesNb; i++)
|
||
|
|
{
|
||
|
|
vertex = polygon.Vertices[i];
|
||
|
|
vertexVB = vba.getVertexCoordPointer(i+verticesNb+2);
|
||
|
|
*vertexVB = CVector(vertex.x, vertex.y, -height) - cameraPos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// new matrix model/view to reposition in camera position
|
||
|
|
Driver->setModelMatrix(CMatrix::Identity);
|
||
|
|
|
||
|
|
CMatrix viewMatrix = Driver->getViewMatrix();
|
||
|
|
_OldViewMatrix = viewMatrix;
|
||
|
|
viewMatrix.setPos(CVector::Null);
|
||
|
|
Driver->setViewMatrix(viewMatrix);
|
||
|
|
|
||
|
|
// before drawing shadow volume, we setup an infinite frustum
|
||
|
|
// and a [0, 1] depth range
|
||
|
|
infiniteFrustum();
|
||
|
|
}
|
||
|
|
|
||
|
|
// render Vertex Buffer
|
||
|
|
((CDriverUser*)Driver)->getDriver()->activeVertexBuffer(_PolyVB[poly-1]);
|
||
|
|
((CDriverUser*)Driver)->getDriver()->activeIndexBuffer(_PolyIB[poly-1]);
|
||
|
|
((CDriverUser*)Driver)->getDriver()->renderTriangles(
|
||
|
|
*GenericMat.getObjectPtr(), 0, 4*(uint32)_Polygons[poly-1].Vertices.size());
|
||
|
|
|
||
|
|
if(!firstPass)
|
||
|
|
{
|
||
|
|
// we recover initial (finite) projection matrix
|
||
|
|
finiteFrustum();
|
||
|
|
|
||
|
|
// setup old model/view matrix
|
||
|
|
Driver->setViewMatrix(_OldViewMatrix);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::drawPolygon(uint poly)
|
||
|
|
{
|
||
|
|
GenericMat.setZWrite(false);
|
||
|
|
|
||
|
|
const CRGBA & currentColor = GenericMat.getColor();
|
||
|
|
|
||
|
|
// activation of transparency
|
||
|
|
GenericMat.setBlend(true);
|
||
|
|
GenericMat.setBlendFunc(UMaterial::srcalpha, UMaterial::invsrcalpha);
|
||
|
|
GenericMat.getObjectPtr()->setOpacity(128);
|
||
|
|
GenericMat.getObjectPtr()->setColor(_PolyColor[poly-1]);
|
||
|
|
|
||
|
|
// draw a half transparent rectangle which covers all scissor rectangle
|
||
|
|
Driver->setMatrixMode2D11();
|
||
|
|
Driver->drawQuad(_Shadow, GenericMat);
|
||
|
|
UCamera cam = Scene->getCam();
|
||
|
|
Driver->setMatrixMode3D(cam);
|
||
|
|
|
||
|
|
// reset old material of scene
|
||
|
|
GenericMat.setBlend(false);
|
||
|
|
GenericMat.setColor(currentColor);
|
||
|
|
|
||
|
|
GenericMat.setZWrite(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::deletePolygons()
|
||
|
|
{
|
||
|
|
uint i;
|
||
|
|
|
||
|
|
_Polygons.clear();
|
||
|
|
_Barycenters.clear();
|
||
|
|
_PolyColor.clear();
|
||
|
|
_BBoxes.clear();
|
||
|
|
|
||
|
|
for(i=0; i<_PolyVB.size(); i++)
|
||
|
|
{
|
||
|
|
_PolyVB[i].deleteAllVertices();
|
||
|
|
}
|
||
|
|
_PolyVB.clear();
|
||
|
|
|
||
|
|
for(i=0; i<_PolyIB.size(); i++)
|
||
|
|
{
|
||
|
|
_PolyIB[i].deleteAllIndexes();
|
||
|
|
}
|
||
|
|
_PolyIB.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
void CLandscapePolyDrawer::computeBBoxFromPolygon(const NLMISC::CPolygon2D &poly2D,
|
||
|
|
NLMISC::CAABBox &destBBox)
|
||
|
|
{
|
||
|
|
if (poly2D.Vertices.empty())
|
||
|
|
{
|
||
|
|
destBBox.setMinMax(CVector::Null, CVector::Null);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// search for min and max dimensions of polygon on x and y axes.
|
||
|
|
CVector2f point = poly2D.Vertices[0];
|
||
|
|
CVector2f rectMax(point), rectMin(point);
|
||
|
|
for(uint i=1; i<poly2D.Vertices.size(); i++)
|
||
|
|
{
|
||
|
|
point = poly2D.Vertices[i];
|
||
|
|
|
||
|
|
rectMax.x = std::max(rectMax.x, point.x);
|
||
|
|
rectMax.y = std::max(rectMax.y, point.y);
|
||
|
|
rectMin.x = std::min(rectMin.x, point.x);
|
||
|
|
rectMin.y = std::min(rectMin.y, point.y);
|
||
|
|
}
|
||
|
|
|
||
|
|
// init bounding box
|
||
|
|
float w = rectMax.x - rectMin.x, h = rectMax.y - rectMin.y;
|
||
|
|
destBBox.setCenter(CVector(rectMin.x + w/2 , rectMin.y + h/2, 0));
|
||
|
|
destBBox.setHalfSize(CVector(w/2 , h/2, 0));
|
||
|
|
|
||
|
|
// search for zones list on which the polygon will be "projected".
|
||
|
|
uint zoneDim = 160;
|
||
|
|
sint32 xmin = ((uint)(rectMin.x/zoneDim))*zoneDim;
|
||
|
|
sint32 xmax = ((uint)(rectMax.x/zoneDim))*zoneDim;
|
||
|
|
sint32 ymin = (((uint)(rectMin.y/zoneDim)))*zoneDim;
|
||
|
|
sint32 ymax = (((uint)(rectMax.y/zoneDim)))*zoneDim;
|
||
|
|
|
||
|
|
std::list<uint16> zoneIds;
|
||
|
|
for(sint32 x=xmin; x<=xmax; x+=zoneDim)
|
||
|
|
{
|
||
|
|
for(sint32 y=ymin; y<=ymax; y+=zoneDim)
|
||
|
|
{
|
||
|
|
float xcount = (float)(x/zoneDim);
|
||
|
|
float ycount = (float)(-y/zoneDim) + 1;
|
||
|
|
|
||
|
|
uint16 zoneId = (uint16) ((ycount-1)*256+xcount);
|
||
|
|
zoneIds.push_back(zoneId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// search for min and max dimensions on z axis.
|
||
|
|
bool firstExtend = true;
|
||
|
|
std::list<uint16>::iterator it;
|
||
|
|
for(it=zoneIds.begin(); it!=zoneIds.end(); it++)
|
||
|
|
{
|
||
|
|
if (Landscape)
|
||
|
|
{
|
||
|
|
const CZone* zone = Landscape->getZone(*it);
|
||
|
|
if(zone)
|
||
|
|
{
|
||
|
|
// For each zone, we traverse its patchs and check intersection between our polygon
|
||
|
|
// bounding rectangle on (x, y) plane and the bounding sphere patch .
|
||
|
|
// If intersection, we use the bounding box of the patch to extend the polygon boudning box
|
||
|
|
// on z axis.
|
||
|
|
// NB : The patch bounding box isn't used immediately because it's more expensive
|
||
|
|
// to obtain than bounding sphere.
|
||
|
|
sint numPatchs = zone->getNumPatchs();
|
||
|
|
for(sint i=0; i<numPatchs; i++)
|
||
|
|
{
|
||
|
|
const CBSphere& bSphere = zone->getPatchBSphere(i);
|
||
|
|
|
||
|
|
const CVector2f sphereMax = CVector2f(bSphere.Center.x + bSphere.Radius,
|
||
|
|
bSphere.Center.y + bSphere.Radius);
|
||
|
|
const CVector2f sphereMin = CVector2f(bSphere.Center.x - bSphere.Radius,
|
||
|
|
bSphere.Center.y - bSphere.Radius);
|
||
|
|
|
||
|
|
// intersection beetween patch bounding sphere and polygon bounding rectangle
|
||
|
|
if(sphereMin.x<rectMax.x && sphereMax.x>rectMin.x && sphereMin.y<rectMax.y
|
||
|
|
&& sphereMax.y>rectMin.y)
|
||
|
|
{
|
||
|
|
const CPatch* patch = zone->getPatch(i);
|
||
|
|
const CAABBox & patchBBox = patch->buildBBox();
|
||
|
|
const CVector& center = patchBBox.getCenter();
|
||
|
|
const CVector& halfSize = patchBBox.getHalfSize();
|
||
|
|
|
||
|
|
const CVector2f patchMax = CVector2f(center.x + halfSize.x, center.y + halfSize.y);
|
||
|
|
const CVector2f patchMin = CVector2f(center.x - halfSize.x, center.y - halfSize.y);
|
||
|
|
|
||
|
|
// intersection beetween patch bounding box and polygon bounding rectangle
|
||
|
|
if(patchMin.x<rectMax.x && patchMax.x>rectMin.x && patchMin.y<rectMax.y
|
||
|
|
&& patchMax.y>rectMin.y)
|
||
|
|
{
|
||
|
|
if(firstExtend)
|
||
|
|
{
|
||
|
|
destBBox.setCenter(CVector(destBBox.getCenter().x, destBBox.getCenter().y,
|
||
|
|
center.z));
|
||
|
|
destBBox.setHalfSize(CVector(destBBox.getHalfSize().x, destBBox.getHalfSize().y,
|
||
|
|
halfSize.z));
|
||
|
|
firstExtend = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
float zmin=destBBox.getCenter().z-destBBox.getHalfSize().z;
|
||
|
|
float zmax=destBBox.getCenter().z+destBBox.getHalfSize().z;
|
||
|
|
|
||
|
|
if(center.z-halfSize.z < zmin)
|
||
|
|
zmin = center.z-halfSize.z;
|
||
|
|
if(center.z+halfSize.z > zmax)
|
||
|
|
zmax = center.z+halfSize.z;
|
||
|
|
|
||
|
|
destBBox.setCenter(CVector(destBBox.getCenter().x, destBBox.getCenter().y,
|
||
|
|
zmin + (zmax-zmin)/2));
|
||
|
|
destBBox.setHalfSize(CVector(destBBox.getHalfSize().x, destBBox.getHalfSize().y,
|
||
|
|
(zmax-zmin)/2));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------------------------------------
|
||
|
|
|