aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-19 13:36:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/nel/src/3d/water_model.cpp

2019 lines
68 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"
#include "nel/misc/vector_2f.h"
#include "nel/misc/vector_h.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/3d/animation_time.h"
#include "nel/3d/water_model.h"
#include "nel/3d/water_shape.h"
#include "nel/3d/water_pool_manager.h"
#include "nel/3d/water_height_map.h"
#include "nel/3d/dru.h"
#include "nel/3d/scene.h"
#include "nel/3d/driver.h"
#include "nel/3d/render_trav.h"
#include "nel/3d/anim_detail_trav.h"
#include "nel/3d/texture_emboss.h"
#include "nel/3d/texture_bump.h"
#include "nel/3d/water_env_map.h"
using NLMISC::CVector2f;
namespace NL3D {
// for normal rendering
CMaterial CWaterModel::_WaterMat;
// for simple rendering
CMaterial CWaterModel::_SimpleWaterMat;
const uint WATER_MODEL_DEFAULT_NUM_VERTICES = 5000;
NLMISC::CRefPtr<IDriver> CWaterModel::_CurrDrv;
// TMP
volatile bool forceWaterSimpleRender = false;
//=======================================================================
void CWaterModel::setupVertexBuffer(CVertexBuffer &vb, uint numWantedVertices, IDriver *drv)
{
if (!numWantedVertices) return;
if (vb.getNumVertices() == 0 || drv != _CurrDrv) // not setupped yet, or driver changed ?
{
vb.setNumVertices(0);
vb.setName("Water");
vb.setPreferredMemory(CVertexBuffer::AGPPreferred, false);
if (drv->isWaterShaderSupported())
{
vb.setVertexFormat(CVertexBuffer::PositionFlag);
}
else
{
vb.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag);
}
_CurrDrv = drv;
}
uint numVerts = std::max(numWantedVertices, WATER_MODEL_DEFAULT_NUM_VERTICES);
if (numVerts > vb.getNumVertices())
{
const uint vb_INCREASE_SIZE = 1000;
numVerts = vb_INCREASE_SIZE * ((numVerts + (vb_INCREASE_SIZE - 1)) / vb_INCREASE_SIZE); // snap size
vb.setNumVertices((uint32) numVerts);
}
}
//=======================================================================
CWaterModel::CWaterModel()
{
setOpacity(false);
setTransparency(true);
setOrderingLayer(1);
// RenderFilter: We are a SegRemanece
_RenderFilterType= UScene::FilterWater;
_Prev = NULL;
_Next = NULL;
_MatrixUpdateDate = 0;
}
//=======================================================================
CWaterModel::~CWaterModel()
{
CScene *scene = getOwnerScene();
if (scene && scene->getWaterCallback())
{
nlassert(Shape);
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
scene->getWaterCallback()->waterSurfaceRemoved(ws->getUseSceneWaterEnvMap(0) || ws->getUseSceneWaterEnvMap(1));
}
// should be already unlinked, but security
unlink();
}
//=======================================================================
void CWaterModel::registerBasic()
{
CScene::registerModel(WaterModelClassId, TransformShapeId, CWaterModel::creator);
}
//=======================================================================
ITrack* CWaterModel::getDefaultTrack (uint valueId)
{
nlassert(Shape);
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
switch (valueId)
{
case PosValue: return ws->getDefaultPos(); break;
case ScaleValue: return ws->getDefaultScale(); break;
case RotQuatValue: return ws->getDefaultRotQuat(); break;
default: // delegate to parent
return CTransformShape::getDefaultTrack(valueId);
break;
}
}
//=======================================================================
uint32 CWaterModel::getWaterHeightMapID() const
{
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
return ws->_WaterPoolID;
}
//=======================================================================
float CWaterModel::getHeightFactor() const
{
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
return ws->_WaveHeightFactor;
}
//=======================================================================
float CWaterModel::getHeight(const CVector2f &pos)
{
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
CWaterHeightMap &whm = GetWaterPoolManager().getPoolByID(ws->_WaterPoolID);
const float height = whm.getHeight(pos);
return height * ws->_WaveHeightFactor + this->getPos().z;
}
//=======================================================================
float CWaterModel::getAttenuatedHeight(const CVector2f &pos, const NLMISC::CVector &viewer)
{
CWaterShape *ws = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
CWaterHeightMap &whm = GetWaterPoolManager().getPoolByID(ws->_WaterPoolID);
const float maxDist = whm.getUnitSize() * (whm.getSize() >> 1);
const NLMISC::CVector planePos(pos.x, pos.y, this->getMatrix().getPos().z);
const float userDist = (planePos - viewer).norm();
if (userDist > maxDist)
{
return this->getMatrix().getPos().z;
}
else
{
const float height = whm.getHeight(pos);
return ws->_WaveHeightFactor * height * (1.f - userDist / maxDist) + this->getMatrix().getPos().z;
}
}
//=======================================================================
// perform a bilinear on 4 values
// 0---1
// | |
// 3---2
/*
static float inline BilinFilter(float v0, float v1, float v2, float v3, float u, float v)
{
float g = v * v3 + (1.f - v) * v0;
float h = v * v2 + (1.f - v) * v1;
return u * h + (1.f - u) * g;
}
*/
//=======================================================================
/// store a value in a water vertex buffer, and increment the pointer
/*
static void inline FillWaterVB(uint8 *&vbPointer, float x, float y, float z, float nx, float ny)
{
* (float *) vbPointer = x;
((float *) vbPointer)[1] = y;
((float *) vbPointer)[2] = z;
*((float *) (vbPointer + 3 * sizeof(float))) = nx;
*((float *) (vbPointer + 4 * sizeof(float))) = ny;
vbPointer += 5 * sizeof(float);
}
*/
//***************************************************************************************************************
/*
#ifdef NL_OS_WINDOWS
__forceinline
#endif
static void SetupWaterVertex( sint qLeft,
sint qRight,
sint qUp,
sint qDown,
sint qSubLeft,
sint qSubDown,
const NLMISC::CVector &inter,
float invWaterRatio,
sint doubleWaterHeightMapSize,
CWaterHeightMap &whm,
uint8 *&vbPointer,
float offsetX,
float offsetY
)
{
const float wXf = invWaterRatio * (inter.x + offsetX);
const float wYf = invWaterRatio * (inter.y + offsetY);
sint wx = (sint) floorf(wXf);
sint wy = (sint) floorf(wYf);
if (!
(wx >= qLeft && wx < qRight && wy < qUp && wy >= qDown)
)
{
// no perturbation is visible
FillWaterVB(vbPointer, inter.x, inter.y, 0, 0, 0);
}
else
{
// filter height and gradient at the given point
const sint stride = doubleWaterHeightMapSize;
const uint xm = (uint) (wx - qSubLeft);
const uint ym = (uint) (wy - qSubDown);
const sint offset = xm + stride * ym;
const float *ptWater = whm.getPointer() + offset;
float deltaU = wXf - wx;
float deltaV = wYf - wy;
//nlassert(deltaU >= 0.f && deltaU <= 1.f && deltaV >= 0.f && deltaV <= 1.f);
const float *ptWaterPrev = whm.getPrevPointer() + offset;
float g0x, g1x, g2x, g3x; // x gradient for current
float g0xp, g1xp, g2xp, g3xp;
float gradCurrX, gradCurrY;
float g0y, g1y, g2y, g3y; // y gradient for previous map
float g0yp, g1yp, g2yp, g3yp;
float gradPrevX, gradPrevY;
/// curr gradient
g0x = ptWater[ 1] - ptWater[ - 1];
g1x = ptWater[ 2] - ptWater[ 0 ];
g2x = ptWater[ 2 + stride] - ptWater[ stride];
g3x = ptWater[ 1 + stride] - ptWater[ - 1 + stride];
gradCurrX = BilinFilter(g0x, g1x, g2x, g3x, deltaU, deltaV);
g0y = ptWater[ stride] - ptWater[ - stride];
g1y = ptWater[ stride + 1] - ptWater[ - stride + 1];
g2y = ptWater[ (stride << 1) + 1] - ptWater[ 1];
g3y = ptWater[ (stride << 1)] - ptWater[0];
gradCurrY = BilinFilter(g0y, g1y, g2y, g3y, deltaU, deltaV);
/// prev gradient
g0xp = ptWaterPrev[ 1] - ptWaterPrev[ - 1];
g1xp = ptWaterPrev[ 2] - ptWaterPrev[ 0 ];
g2xp = ptWaterPrev[ 2 + stride] - ptWaterPrev[ + stride];
g3xp = ptWaterPrev[ 1 + stride] - ptWaterPrev[ - 1 + stride];
gradPrevX = BilinFilter(g0xp, g1xp, g2xp, g3xp, deltaU, deltaV);
g0yp = ptWaterPrev[ stride] - ptWaterPrev[ - stride];
g1yp = ptWaterPrev[ stride + 1] - ptWaterPrev[ - stride + 1];
g2yp = ptWaterPrev[ (stride << 1) + 1] - ptWaterPrev[ 1 ];
g3yp = ptWaterPrev[ (stride << 1)] - ptWaterPrev[ 0 ];
gradPrevY = BilinFilter(g0yp, g1yp, g2yp, g3yp, deltaU, deltaV);
/// current height
float h = BilinFilter(ptWater[ 0 ], ptWater[ + 1], ptWater[ 1 + stride], ptWater[stride], deltaU, deltaV);
/// previous height
float hPrev = BilinFilter(ptWaterPrev[ 0 ], ptWaterPrev[ 1], ptWaterPrev[ 1 + stride], ptWaterPrev[stride], deltaU, deltaV);
float timeRatio = whm.getBufferRatio();
FillWaterVB(vbPointer, inter.x, inter.y, timeRatio * h + (1.f - timeRatio) * hPrev,
4.5f * (timeRatio * gradCurrX + (1.f - timeRatio) * gradPrevX),
4.5f * (timeRatio * gradCurrY + (1.f - timeRatio) * gradPrevY)
);
//NLMISC::CVector2f *ptGrad = whm.getGradPointer() + offset;
}
}
*/
//*****************************************************************************************************
/*
static void DrawPoly2D(CVertexBuffer &vb, IDriver *drv, const NLMISC::CMatrix &mat, const NLMISC::CPolygon &p)
{
uint k;
{
CVertexBufferReadWrite vba;
vb.lock (vba);
for (k = 0; k < p.Vertices.size(); ++k)
{
NLMISC::CVector tPos = mat * NLMISC::CVector(p.Vertices[k].x, p.Vertices[k].y, 0);
vba.setValueFloat3Ex (WATER_VB_POS, k, tPos.x, tPos.y, tPos.z);
vba.setValueFloat2Ex (WATER_VB_DX, k, 0, 0);
}
}
static CIndexBuffer ib;
ib.setNumIndexes(3 * p.Vertices.size());
{
CIndexBufferReadWrite ibaWrite;
ib.lock (ibaWrite);
uint32 *ptr = ibaWrite.getPtr();
for (k = 0; k < p.Vertices.size() - 2; ++k)
{
ptr[ k * 3 ] = 0;
ptr[ k * 3 + 1 ] = k + 1;
ptr[ k * 3 + 2 ] = k + 2;
}
}
drv->activeIndexBuffer(ib);
drv->renderSimpleTriangles(0, p.Vertices.size() - 2);
}
*/
//***************************************************************************************************************
/*
void CWaterModel::traverseRender()
{
H_AUTO( NL3D_Water_Render );
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
IDriver *drv = renderTrav.getDriver();
#ifndef FORCE_SIMPLE_WATER_RENDER
if (!drv->isWaterShaderSupported())
#endif
{
doSimpleRender(drv);
return;
}
CWaterShape *shape = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
if (shape->_GridSizeTouched)
{
shape->setupVertexBuffer();
}
// inverted object world matrix
//NLMISC::CMatrix invObjMat = getWorldMatrix().inverted();
// viewer pos in world space
const NLMISC::CVector &obsPos = renderTrav.CamPos;
// camera matrix in world space
const NLMISC::CMatrix &camMat = renderTrav.CamMatrix;
// view matrix (inverted cam matrix)
const NLMISC::CMatrix &viewMat = renderTrav.ViewMatrix;
// compute the camera matrix such as there is no rotation around the y axis
NLMISC::CMatrix camMatUp;
ComputeUpMatrix(camMat.getJ(), camMatUp, camMat);
camMatUp.setPos(camMat.getPos());
const NLMISC::CMatrix matViewUp = camMatUp.inverted();
// plane z pos in world
const float zHeight = getWorldMatrix().getPos().z;
const sint numStepX = CWaterShape::getScreenXGridSize();
const sint numStepY = CWaterShape::getScreenYGridSize();
const float invNumStepX = 1.f / numStepX;
const float invNumStepY = 1.f / numStepY;
const uint rotBorderSize = (shape->_MaxGridSize + (shape->_XGridBorder << 1) - numStepX) >> 1;
const sint isAbove = obsPos.z > zHeight ? 1 : 0;
#ifdef NO_WATER_TESSEL
const float transitionDist = renderTrav.Near * 0.99f;
#else
const float transitionDist = shape->_TransitionRatio * renderTrav.Far;
#endif
NLMISC::CMatrix modelMat;
modelMat.setPos(NLMISC::CVector(obsPos.x, obsPos.y, zHeight));
drv->setupModelMatrix(modelMat);
//==================//
// material setup //
//==================//
CWaterHeightMap &whm = GetWaterPoolManager().getPoolByID(shape->_WaterPoolID);
setupMaterialNVertexShader(drv, shape, obsPos, isAbove > 0, whm.getUnitSize() * (whm.getSize() >> 1), zHeight);
drv->setupMaterial(CWaterModel::_WaterMat);
sint numPass = drv->beginMaterialMultiPass();
nlassert(numPass == 1); // for now, we assume water is always rendered in a single pass !
drv->setupMaterialPass(0);
//setAttenuationFactor(drv, false, obsPos, camMat.getJ(), farDist);
//disableAttenuation(drv);
//================================//
// Vertex buffer setup //
//================================//
drv->activeVertexBuffer(shape->_VB);
//================================//
// tesselated part of the poly //
//================================//
if (_ClippedPoly.Vertices.size())
{
//======================================//
// Polygon projection on the near plane //
//======================================//
static NLMISC::CPolygon2D projPoly; // projected poly
projPoly.Vertices.resize(_ClippedPoly.Vertices.size());
const float Near = renderTrav.Near;
const float xFactor = numStepX * Near / (renderTrav.Right - renderTrav.Left);
const float xOffset = numStepX * (-renderTrav.Left / (renderTrav.Right - renderTrav.Left)) + 0.5f;
const float yFactor = numStepY * Near / (renderTrav.Bottom - renderTrav.Top);
const float yOffset = numStepY * (-renderTrav.Top / (renderTrav.Bottom - renderTrav.Top)) - 0.5f * isAbove;
const NLMISC::CMatrix projMat = matViewUp * getWorldMatrix();
uint k;
for (k = 0; k < _ClippedPoly.Vertices.size(); ++k)
{
// project points in the view
NLMISC::CVector t = projMat * _ClippedPoly.Vertices[k];
float invY = 1.f / t.y;
projPoly.Vertices[k].set(xFactor * t.x * invY + xOffset, yFactor * t.z * invY + yOffset);
}
//=============================================//
// compute borders of poly at a low resolution //
//=============================================//
NLMISC::CPolygon2D::TRasterVect rasters;
sint startY;
projPoly.computeBorders(rasters, startY);
if (rasters.size())
{
//===========================//
// perform Water animation //
//===========================//
const float WaterRatio = whm.getUnitSize();
const float invWaterRatio = 1.f / WaterRatio;
const uint WaterHeightMapSize = whm.getSize();
const uint doubleWaterHeightMapSize = (WaterHeightMapSize << 1);
sint64 idate = getOwnerScene()->getHrcTrav().CurrentDate;
if (idate != whm.Date)
{
whm.setUserPos((sint) (obsPos.x * invWaterRatio) - (WaterHeightMapSize >> 1),
(sint) (obsPos.y * invWaterRatio) - (WaterHeightMapSize >> 1)
);
nlassert(getOwnerScene()); // this object should have been created from a CWaterShape!
whm.animate((float) (getOwnerScene()->getEllapsedTime()));
whm.Date = idate;
}
//float startDate = (float) (1000.f * NLMISC::CTime::ticksToSecond(NLMISC::CTime::getPerformanceTime()));
//=====================================//
// compute heightmap useful area //
//=====================================//
// We don't store a heighmap for a complete Water area
// we just consider the height of Water columns that are near the observer
//
// Compute a quad in Water height field space that contains the useful heights
// This helps us to decide whether we should do a lookup in the height map
sint mapPosX, mapPosY;
/// get the pos used in the height map (may not be the same than our current pos, has it is taken in account
/// every 'PropagationTime' second
whm.getUserPos(mapPosX, mapPosY);
const uint mapBorder = 3;
const sint qRight = (sint) mapPosX + WaterHeightMapSize - mapBorder;
sint qLeft = (sint) mapPosX;
const sint qUp = (sint) mapPosY + WaterHeightMapSize - mapBorder;
sint qDown = (sint) mapPosY;
/// Compute the origin of the area of Water covered by the height map. We use this to converted from object space to 2d map space
const sint qSubLeft = qLeft - (uint) qLeft % WaterHeightMapSize;
const sint qSubDown = qDown - (uint) qDown % WaterHeightMapSize;
qLeft += mapBorder;
qDown += mapBorder;
//==============================================//
// setup rays to be traced, and their increment //
//==============================================//
// compute camera rays in world space
NLMISC::CVector currHV = renderTrav.Left * camMatUp.getI() + renderTrav.Near * camMatUp.getJ() + renderTrav.Top * camMatUp.getK(); // current border vector, incremented at each line
NLMISC::CVector currV; // current ray vector
NLMISC::CVector xStep = (renderTrav.Right - renderTrav.Left) * invNumStepX * camMatUp.getI(); // xStep for the ray vector
NLMISC::CVector yStep = (renderTrav.Bottom - renderTrav.Top) * invNumStepY * camMatUp.getK(); // yStep for the ray vector
//===============================================//
// perform display //
//===============================================//
// scale currHV at the top of the poly
currHV += (startY - 0.5f * isAbove) * yStep;
// current index buffer used. We swap each time a row has been drawn
CIndexBuffer *currIB = &CWaterShape::_IBUpDown, *otherIB = &CWaterShape::_IBDownUp;
sint vIndex = 0; // index in vertices
// current raster position
sint oldStartX, oldEndX, realStartX, realEndX;
//float invNearWidth = numStepX / (renderTrav.Right - renderTrav.Left);
//nlinfo("size = %d, maxSize = ", rasters.size(), numStepY);
const uint wqHeight = rasters.size();
if (wqHeight)
{
// denominator of the intersection equation
const float denom = - obsPos.z + zHeight;
// test the upper raster
// if it is above the horizon, we modify it to reach the correct location
const float horizonEpsilon = 10E-4f; // we must be a little below the horizon
// distance from the viewer along the traced ray
float t;
NLMISC::CPolygon2D::TRasterVect::const_iterator it = rasters.begin();
for (uint l = 0; l <= wqHeight; ++l)
{
//nlinfo("start = %d, end = %d", it->first, it->second);
const sint startX = it->first;
const sint endX = (it->second + 1);
nlassert(startX >= - (sint) rotBorderSize);
nlassert(endX <= (sint) (numStepX + rotBorderSize));
if (l != 0)
{
realStartX = std::min(startX, oldStartX);
realEndX = std::max(endX, oldEndX);
}
else
{
realStartX = startX;
realEndX = endX;
}
// current view vector
currV = currHV + (realStartX - 0.5f) * xStep;
if (l == 0)
{
if (isAbove)
{
// test whether the first row is out of horizon.
// if this is the case, we make a correction
if (denom * currV.z <= 0)
{
// correct for the first line only by adding a y offset
currV += yStep * ((denom > 0 ? horizonEpsilon : - horizonEpsilon) - currV.z) / yStep.z;
}
// now, for the transition, check whether the first raster does not go over the transition dist
t = denom / currV.z;
const float VJ = camMat.getJ() * currV;
if ( t * VJ > transitionDist)
{
float delta = (1.f / yStep.z) * ( denom * VJ / transitionDist - currV.z);
// correct the first line to reach that position
currV += delta * yStep;
}
}
}
{
CVertexBufferReadWrite vba;
shape->_VB.lock (vba);
uint8 *vbPointer = (uint8 *) vba.getVertexCoordPointer() + shape->_VB.getVertexSize() * (vIndex + realStartX + rotBorderSize);
for (sint k = realStartX; k <= realEndX; ++k)
{
t = denom / currV.z;
// compute intersection with plane
NLMISC::CVector inter = t * currV;
inter.z += obsPos.z;
SetupWaterVertex(qLeft, qRight, qUp, qDown, qSubLeft, qSubDown, inter, invWaterRatio, doubleWaterHeightMapSize, whm, vbPointer, obsPos.x, obsPos.y);
currV += xStep;
}
}
if (l != 0) // 2 line of the ib done ?
{
sint count = oldEndX - oldStartX;
if (count > 0)
{
drv->activeIndexBuffer(*currIB);
drv->renderSimpleTriangles((oldStartX + rotBorderSize) * 6, 2 * count );
}
}
oldStartX = startX;
oldEndX = endX;
currHV += yStep;
vIndex = (numStepX + 2 * rotBorderSize + 1) - vIndex; // swap first row and second row
std::swap(currIB, otherIB);
if (l < (wqHeight - 1))
{
++it;
}
else
{
if (!isAbove)
{
// last line
// test whether we are out of horizon
if (denom * currHV.z <= 0)
{
// correct for the first line only by adding a y offset
currHV += yStep * ((denom > 0 ? horizonEpsilon : - horizonEpsilon) - currHV.z) / yStep.z;
}
// now, for the transition, check whether the first raster does not go over the transition dist
t = denom / currHV.z;
const float VJ = camMat.getJ() * currHV;
if ( t * VJ > transitionDist)
{
float delta = (1.f / yStep.z) * ( denom * VJ / transitionDist - currHV.z);
// correct the first line to reach that position
currHV += delta * yStep;
}
}
}
}
}
//nlinfo("display: %f ms", (float) (1000.f * NLMISC::CTime::ticksToSecond(NLMISC::CTime::getPerformanceTime()) - startDate));
}
}
//=========================================//
// display end poly //
//=========================================//
if (_EndClippedPoly.Vertices.size() != 0)
{
CMatrix xform = _WorldMatrix;
xform.movePos(NLMISC::CVector(- obsPos.x, - obsPos.y, _WorldMatrix.getPos().z));
DrawPoly2D(shape->_VB, drv, xform, _EndClippedPoly);
}
drv->endMaterialMultiPass();
drv->activeVertexProgram(NULL);
}
*/
//***********************
// Water MATERIAL SETUP //
//***********************
/*
void CWaterModel::setupMaterialNVertexShader(IDriver *drv, CWaterShape *shape, const NLMISC::CVector &obsPos, bool above, float maxDist, float zHeight)
{
static bool matSetupped = false;
if (!matSetupped)
{
_WaterMat.setLighting(false);
_WaterMat.setDoubleSided(true);
_WaterMat.setColor(NLMISC::CRGBA::White);
_WaterMat.setBlend(true);
_WaterMat.setSrcBlend(CMaterial::srcalpha);
_WaterMat.setDstBlend(CMaterial::invsrcalpha);
_WaterMat.setZWrite(true);
_WaterMat.setShader(CMaterial::Water);
}
const uint cstOffset = 4; // 4 places for the matrix
NLMISC::CVectorH cst[13];
//=========================//
// setup Water material //
//=========================//
CWaterModel::_WaterMat.setTexture(0, shape->_BumpMap[0]);
CWaterModel::_WaterMat.setTexture(1, shape->_BumpMap[1]);
CWaterModel::_WaterMat.setTexture(3, shape->_ColorMap);
CScene *scene = getOwnerScene();
if (!above && shape->_EnvMap[1])
{
if (shape->_UsesSceneWaterEnvMap[1])
{
if (scene->getWaterEnvMap())
{
CWaterModel::_WaterMat.setTexture(2, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[1]);
}
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[1]);
}
}
else
{
if (shape->_UsesSceneWaterEnvMap[0])
{
if (scene->getWaterEnvMap())
{
CWaterModel::_WaterMat.setTexture(2, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[0]);
}
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[0]);
}
}
shape->envMapUpdate();
const uint alphaMapStage = 3;
if (shape->_ColorMap)
{
//WaterMat.setTexture(alphaMapStage, shape->_ColorMap);
//if (shape->_ColorMap->supportSharing()) nlinfo(shape->_ColorMap->getShareName().c_str());
// setup 2x3 matrix for lookup in diffuse map
updateDiffuseMapMatrix();
cst[13 - cstOffset].set(_ColorMapMatColumn0.x, _ColorMapMatColumn1.x, 0, _ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x);
cst[14 - cstOffset].set(_ColorMapMatColumn0.y, _ColorMapMatColumn1.y, 0, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y);
}
else
{
cst[13 - cstOffset].set(0, 0, 0, 0);
cst[14 - cstOffset].set(0, 0, 0, 0);
}
cst[16 - cstOffset].set(0.1f, 0.1f, 0.1f, 0.1f); // used to avoid imprecision when performing a RSQ to get distance from the origin
// cst[16 - cstOffset].set(0.0f, 0.0f, 0.0f, 0.0f); // used to avoid imprecision when performing a RSQ to get distance from the origin
cst[5 - cstOffset].set(0.f, 0.f, 0.f, 0.f); // claping negative values to 0
// slope of attenuation of normal / height with distance
const float invMaxDist = shape->_WaveHeightFactor / maxDist;
cst[6 - cstOffset].set(invMaxDist, shape->_WaveHeightFactor, 0, 0);
/// set matrix
drv->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
drv->setConstantFog(18);
// retrieve current time
float date = 0.001f * (NLMISC::CTime::getLocalTime() & 0xffffff); // must keep some precision.
// set bumpmaps pos
cst[9 - cstOffset].set(fmodf(obsPos.x * shape->_HeightMapScale[0].x, 1.f) + fmodf(date * shape->_HeightMapSpeed[0].x, 1.f), fmodf(shape->_HeightMapScale[0].y * obsPos.y, 1.f) + fmodf(date * shape->_HeightMapSpeed[0].y, 1.f), 0.f, 1.f); // bump map 0 offset
cst[10 - cstOffset].set(shape->_HeightMapScale[0].x, shape->_HeightMapScale[0].y, 0, 0); // bump map 0 scale
cst[11 - cstOffset].set(fmodf(shape->_HeightMapScale[1].x * obsPos.x, 1.f) + fmodf(date * shape->_HeightMapSpeed[1].x, 1.f), fmodf(shape->_HeightMapScale[1].y * obsPos.y, 1.f) + fmodf(date * shape->_HeightMapSpeed[1].y, 1.f), 0.f, 1.f); // bump map 1 offset
cst[12 - cstOffset].set(shape->_HeightMapScale[1].x, shape->_HeightMapScale[1].y, 0, 0); // bump map 1 scale
cst[4 - cstOffset].set(1.f, 1.f, 1.f, 1.f); // use with min man, and to get the 1 constant
cst[7 - cstOffset].set(0, 0, obsPos.z - zHeight, 1.f);
cst[8 - cstOffset].set(0.5f, 0.5f, 0.f, 1.f); // used to scale reflected ray into the envmap
/// set all our constants in one call
drv->setConstant(4, sizeof(cst) / sizeof(cst[0]), (float *) &cst[0]);
shape->initVertexProgram();
bool result;
//if (useBumpedVersion)
//{
// if (!useEMBM)
// {
// result = shape->getColorMap() ? drv->activeVertexProgram((shape->_VertexProgramBump2Diffuse).get())
// : drv->activeVertexProgram((shape->_VertexProgramBump2).get());
// }
// else
// {
// result = shape->getColorMap() ? drv->activeVertexProgram((shape->_VertexProgramBump1Diffuse).get())
// : drv->activeVertexProgram((shape->_VertexProgramBump1).get());
// }
//}
//else
//{
// result = shape->getColorMap() ? drv->activeVertexProgram((shape->_VertexProgramNoBumpDiffuse).get())
// : drv->activeVertexProgram((shape->_VertexProgramNoBump).get());
//}
//result = shape->getColorMap() ? drv->activeVertexProgram((shape->_VertexProgramBump2Diffuse).get())
// : drv->activeVertexProgram((shape->_VertexProgramBump2).get());
//
//if (!result) nlwarning("no vertex program setuped");
}
*/
void CWaterModel::setupMaterialNVertexShader(IDriver *drv, CWaterShape *shape, const NLMISC::CVector &obsPos, bool above, float zHeight)
{
static bool matSetupped = false;
if (!matSetupped)
{
_WaterMat.setLighting(false);
_WaterMat.setDoubleSided(true);
_WaterMat.setColor(NLMISC::CRGBA::White);
_WaterMat.setBlend(true);
_WaterMat.setSrcBlend(CMaterial::srcalpha);
_WaterMat.setDstBlend(CMaterial::invsrcalpha);
_WaterMat.setZWrite(true);
_WaterMat.setShader(CMaterial::Water);
}
const uint cstOffset = 5; // 4 places for the matrix
NLMISC::CVectorH cst[13];
//=========================//
// setup Water material //
//=========================//
CWaterModel::_WaterMat.setTexture(0, shape->_BumpMap[0]);
CWaterModel::_WaterMat.setTexture(1, shape->_BumpMap[1]);
CWaterModel::_WaterMat.setTexture(3, shape->_ColorMap);
CScene *scene = getOwnerScene();
if (!above && shape->_EnvMap[1])
{
if (shape->_UsesSceneWaterEnvMap[1])
{
if (scene->getWaterEnvMap())
{
CWaterModel::_WaterMat.setTexture(2, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[1]);
}
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[1]);
}
}
else
{
if (shape->_UsesSceneWaterEnvMap[0])
{
if (scene->getWaterEnvMap())
{
CWaterModel::_WaterMat.setTexture(2, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[0]);
}
}
else
{
CWaterModel::_WaterMat.setTexture(2, shape->_EnvMap[0]);
}
}
shape->envMapUpdate();
if (shape->_ColorMap)
{
// setup 2x3 matrix for lookup in diffuse map
updateDiffuseMapMatrix();
cst[11].set(_ColorMapMatColumn0.x, _ColorMapMatColumn1.x, 0, _ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x);
cst[12].set(_ColorMapMatColumn0.y, _ColorMapMatColumn1.y, 0, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y);
}
/// set matrix
drv->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
// retrieve current time
double date = scene->getCurrentTime();
// set bumpmaps pos
cst[6].set(fmodf(obsPos.x * shape->_HeightMapScale[0].x, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[0].x, 1), fmodf(shape->_HeightMapScale[0].y * obsPos.y, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[0].y, 1), 0.f, 1.f); // bump map 0 offset
cst[5].set(shape->_HeightMapScale[0].x, shape->_HeightMapScale[0].y, 0, 0); // bump map 0 scale
cst[8].set(fmodf(shape->_HeightMapScale[1].x * obsPos.x, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[1].x, 1), fmodf(shape->_HeightMapScale[1].y * obsPos.y, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[1].y, 1), 0.f, 1.f); // bump map 1 offset
cst[7].set(shape->_HeightMapScale[1].x, shape->_HeightMapScale[1].y, 0, 0); // bump map 1 scale
cst[9].set(0, 0, obsPos.z - zHeight, 1.f);
cst[10].set(0.5f, 0.5f, 0.f, 1.f); // used to scale reflected ray into the envmap
/// set all our constants in one call
drv->setConstant(cstOffset, sizeof(cst) / sizeof(cst[0]) - cstOffset, (float *) &cst[cstOffset]);
shape->initVertexProgram();
drv->activeVertexProgram(shape->_ColorMap ? CWaterShape::_VertexProgramNoWaveDiffuse.get() : CWaterShape::_VertexProgramNoWave.get());
drv->setConstantFog(4);
}
//================================================
void CWaterModel::setupSimpleRender(CWaterShape *shape, const NLMISC::CVector &obsPos, bool above)
{
// rendering of water when no vertex / pixel shaders are available
static bool init = false;
if (!init)
{
// setup the material, no special shader is used here
_SimpleWaterMat.setLighting(false);
_SimpleWaterMat.setDoubleSided(true);
_SimpleWaterMat.setColor(NLMISC::CRGBA::White);
_SimpleWaterMat.setBlend(true);
_SimpleWaterMat.setSrcBlend(CMaterial::srcalpha);
_SimpleWaterMat.setDstBlend(CMaterial::invsrcalpha);
_SimpleWaterMat.setZWrite(true);
_SimpleWaterMat.setShader(CMaterial::Normal);
// stage 0
_SimpleWaterMat.texEnvOpRGB(0, CMaterial::Replace);
_SimpleWaterMat.texEnvOpAlpha(0, CMaterial::Replace);
_SimpleWaterMat.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
// stage 1
_SimpleWaterMat.texEnvOpRGB(1, CMaterial::Modulate);
_SimpleWaterMat.texEnvOpAlpha(1, CMaterial::Modulate);
_SimpleWaterMat.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
_SimpleWaterMat.texEnvArg1RGB(0, CMaterial::Previous, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg1Alpha(0, CMaterial::Previous, CMaterial::SrcAlpha);
init = true;
}
// envmap is always present and is in stage 0
CScene *scene = getOwnerScene();
if (!above && shape->_EnvMap[1])
{
if (shape->_UsesSceneWaterEnvMap[1])
{
if (scene->getWaterEnvMap())
{
_SimpleWaterMat.setTexture(0, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[1]);
}
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[1]);
}
}
else
{
if (shape->_UsesSceneWaterEnvMap[0])
{
if (scene->getWaterEnvMap())
{
_SimpleWaterMat.setTexture(0, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[0]);
}
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[0]);
}
}
//
if (shape->_ColorMap == NULL)
{
// version with no color map
if (!_EmbossTexture)
{
_EmbossTexture = new CTextureEmboss;
_EmbossTexture->setSlopeFactor(4.f);
}
if (shape->_BumpMap[1] && shape->_BumpMap[1]->isBumpMap())
{
CTextureBump *bm = static_cast<CTextureBump *>((ITexture *) shape->_BumpMap[1]);
if (bm->getHeightMap())
{
_EmbossTexture->setHeightMap(bm->getHeightMap());
}
}
_SimpleWaterMat.setTexture(1, _EmbossTexture);
_SimpleWaterMat.setTexCoordGen(1, true);
_SimpleWaterMat.setTexCoordGenMode(1, CMaterial::TexCoordGenObjectSpace);
double date = scene->getCurrentTime();
CMatrix texMat;
texMat.scale(CVector(shape->_HeightMapScale[1].x, shape->_HeightMapScale[1].y, 1.f));
texMat.setPos(CVector(fmodf(shape->_HeightMapScale[1].x * obsPos.x, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[1].x, 1),
fmodf(shape->_HeightMapScale[1].y * obsPos.y, 1.f) + (float) fmod(date * shape->_HeightMapSpeed[1].y, 1),
1.f)
);
_SimpleWaterMat.enableUserTexMat(1, true);
_SimpleWaterMat.setUserTexMat(1, texMat);
}
else
{
updateDiffuseMapMatrix();
// version with a color map : it remplace the emboss texture
_SimpleWaterMat.setTexture(1, shape->_ColorMap);
_SimpleWaterMat.setTexCoordGen(1, true);
_SimpleWaterMat.setTexCoordGenMode(1, CMaterial::TexCoordGenObjectSpace);
CMatrix texMat;
/*
float mat[16] =
{
_ColorMapMatColumn0.x, _ColorMapMatColumn1.x, 0, _ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x},
_ColorMapMatColumn0.y, _ColorMapMatColumn1.y, 0, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y,
0.f, 0.f, 1.f, 0.f,
0.f, 0.f, 0.f, 1.f
}
*/
float mat[16] =
{
_ColorMapMatColumn0.x, _ColorMapMatColumn0.y, 0.f, 0.f,
_ColorMapMatColumn1.x, _ColorMapMatColumn1.y, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
_ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y, 0.f, 1.f
};
texMat.set(mat);
_SimpleWaterMat.enableUserTexMat(1, true);
_SimpleWaterMat.setUserTexMat(1, texMat);
}
}
//================================================
void CWaterModel::computeClippedPoly()
{
CWaterShape *shape = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
const std::vector<CPlane> &worldPyramid = getOwnerScene()->getClipTrav().WorldFrustumPyramid;
_ClippedPoly.Vertices.resize(shape->_Poly.Vertices.size());
uint k;
for (k = 0; k < shape->_Poly.Vertices.size(); ++k)
{
_ClippedPoly.Vertices[k].set(shape->_Poly.Vertices[k].x,
shape->_Poly.Vertices[k].y,
0.f
);
}
/*
NLMISC::CPlane plvect[6];
const NLMISC::CMatrix &viewMat = clipTrav.ViewMatrix;
const sint numStepX = CWaterShape::getScreenXGridSize();
const sint numStepY = CWaterShape::getScreenYGridSize();
// Build the view pyramid. We need to rebuild it because we use a wider one to avoid holes on the border of the screen due to water animation
float centerX = 0.5f * (clipTrav.Right + clipTrav.Left);
const float fRight = centerX + (clipTrav.Right - centerX) * (-(float) CWaterShape::_XGridBorder + (float) numStepX) / numStepX;
const float fLeft = centerX + (clipTrav.Left - centerX) * (-(float) CWaterShape::_XGridBorder + (float) numStepX) / numStepX;
float centerY = 0.5f * (clipTrav.Bottom + clipTrav.Top);
const float fTop = centerY + (clipTrav.Top - centerY) * (-(float) CWaterShape::_YGridBorder + (float) numStepY) / numStepY;
const float fBottom = centerY + (clipTrav.Bottom - centerY) * (-(float) CWaterShape::_YGridBorder + (float) numStepY) / numStepY;
// build pyramid corners
const float nearDist = clipTrav.Near;
const float farDist = clipTrav.Far;
//
const NLMISC::CVector pfoc(0,0,0);
const NLMISC::CVector lb( fLeft, nearDist, fBottom );
const NLMISC::CVector lt( fLeft, nearDist, fTop );
const NLMISC::CVector rb( fRight, nearDist, fBottom );
const NLMISC::CVector rt(fRight, nearDist, fTop );
const NLMISC::CVector lbfarDist(fLeft, farDist, fBottom);
const NLMISC::CVector ltfarDist(fLeft, farDist, fTop );
const NLMISC::CVector rtfarDist(fRight , farDist, fTop );
//
plvect[0].make(lt, lb, rt); // near plane
plvect[1].make(lbfarDist, ltfarDist, rtfarDist); // far plane
plvect[2].make(pfoc, lt, lb);
plvect[3].make(pfoc, rt, lt);
plvect[4].make(pfoc, rb, rt);
plvect[5].make(pfoc, lb, rb);
const NLMISC::CMatrix pyramidMat = viewMat * getWorldMatrix();
for (k = 0; k < worldPyramid.size(); ++k)
{
plvect[k] = plvect[k] * pyramidMat; // put the plane in object space
}
_ClippedPoly.clip(plvect, 6);
*/
static std::vector<CPlane> tp;
tp.resize(worldPyramid.size());
for(uint k = 0; k < tp.size(); ++k)
{
tp[k] = worldPyramid[k] * getWorldMatrix();
}
_ClippedPoly.clip(tp);
}
//***********************************************************************************************************
void CWaterModel::unlink()
{
if (!_Prev)
{
nlassert(!_Next);
return;
}
if (_Next)
{
_Next->_Prev = _Prev;
}
*_Prev = _Next;
_Next = NULL;
_Prev = NULL;
}
//***********************************************************************************************************
void CWaterModel::link()
{
nlassert(_Next == NULL);
CScene *scene = getOwnerScene();
nlassert(scene);
CRenderTrav &rt = scene->getRenderTrav();
_Prev = &rt._FirstWaterModel;
_Next = rt._FirstWaterModel;
if (_Next)
{
_Next->_Prev = &_Next;
}
rt._FirstWaterModel = this;
}
//***********************************************************************************************************
uint CWaterModel::getNumWantedVertices()
{
H_AUTO( NL3D_Water_Render );
nlassert(!_ClippedPoly.Vertices.empty());
//
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
if (!renderTrav.Perspective || forceWaterSimpleRender) return 0;
// viewer pos in world space
const NLMISC::CVector &obsPos = renderTrav.CamPos;
// view matrix (inverted cam matrix)
const NLMISC::CMatrix &viewMat = renderTrav.ViewMatrix;
// plane z pos in world
const float zHeight = getWorldMatrix().getPos().z;
const sint numStepX = CWaterShape::getScreenXGridSize();
const sint numStepY = CWaterShape::getScreenYGridSize();
NLMISC::CMatrix modelMat;
modelMat.setPos(NLMISC::CVector(obsPos.x, obsPos.y, zHeight));
static NLMISC::CPolygon2D projPoly; // projected poly
projPoly.Vertices.resize(_ClippedPoly.Vertices.size());
// factor to project to grid units
const float xFactor = numStepX * renderTrav.Near / (renderTrav.Right - renderTrav.Left);
const float yFactor = numStepY * renderTrav.Near / (renderTrav.Top - renderTrav.Bottom);
// project poly on near plane
const NLMISC::CMatrix &projMat = viewMat * getWorldMatrix();
uint k;
for (k = 0; k < _ClippedPoly.Vertices.size(); ++k)
{
// project points in the view
NLMISC::CVector t = projMat * _ClippedPoly.Vertices[k];
float invY = 1.f / t.y;
projPoly.Vertices[k].set(xFactor * t.x * invY, yFactor * t.z * invY);
}
// compute grid cells that are entirely inside
projPoly.computeInnerBorders(_Inside, _MinYInside);
// compute grid cells that are touched
static NLMISC::CPolygon2D::TRasterVect border;
sint minYBorder;
projPoly.computeOuterBorders(border, minYBorder);
// border - inside -> gives grid cells that must be clipped to fit the shape boundaries
// Make sure that rasters array for inside has the same size that raster array for borders (by inserting NULL rasters)
sint height = border.size();
if (_Inside.empty())
{
_MinYInside = minYBorder;
}
sint bottomGap = border.size() - _Inside.size();
_Inside.resize(height);
nlassert(minYBorder == _MinYInside);
nlassert(bottomGap >= 0);
if (bottomGap)
{
for(sint y = height - bottomGap; y < height; ++y)
{
nlassert (y >= 0 && y < (sint)_Inside.size());
_Inside[y].first = border[y].first;
_Inside[y].second = border[y].first - 1; // insert null raster
}
}
//
for(sint y = 0; y < height - bottomGap; ++y)
{
if (_Inside[y].first > _Inside[y].second)
{
nlassert (y >= 0 && y < (sint)_Inside.size());
_Inside[y].first = border[y].first;
_Inside[y].second = border[y].first - 1;
}
else if (border[y].first > border[y].second)
{
nlassert (y >= 0 && y < (sint)_Inside.size());
border[y].first = _Inside[y].first;
border[y].second = _Inside[y].first - 1;
}
}
// compute clip planes
static std::vector<CPlane> clipPlanes;
const CVector2f *prevVert = &projPoly.Vertices.back();
const CVector2f *currVert = &projPoly.Vertices.front();
uint numVerts = projPoly.Vertices.size();
bool ccw = projPoly.isCCWOriented();
clipPlanes.resize(numVerts);
for(uint k = 0; k < numVerts; ++k)
{
NLMISC::CVector v0;
NLMISC::CVector v1;
NLMISC::CVector v2;
v0.set(prevVert->x, prevVert->y, 0.f);
v1.set(currVert->x, currVert->y, 0.f);
v2.set(prevVert->x, prevVert->y, (*currVert - *prevVert).norm());
clipPlanes[k].make(v0, v1, v2);
if (!ccw)
{
clipPlanes[k].invert();
}
prevVert = currVert;
++ currVert;
}
// compute clipped tris
_ClippedTriNumVerts.clear();
_ClippedTris.clear();
static NLMISC::CPolygon clipPoly;
uint totalNumVertices = 0;
// compute number of vertices for whole grid cells
for(sint k = 0; k < (sint) border.size(); ++k)
{
// left clipped blocks
for (sint x = border[k].first; x < _Inside[k].first; ++x)
{
clipPoly.Vertices.resize(4);
clipPoly.Vertices[0].set((float) x, (float) (k + _MinYInside), 0.f);
clipPoly.Vertices[1].set((float) (x + 1), (float) (k + _MinYInside), 0.f);
clipPoly.Vertices[2].set((float) (x + 1), (float) (k + _MinYInside + 1), 0.f);
clipPoly.Vertices[3].set((float) x, (float) (k + _MinYInside + 1), 0.f);
clipPoly.clip(clipPlanes);
if (!clipPoly.Vertices.empty())
{
// backup result (will be unprojected later)
_ClippedTriNumVerts.push_back(clipPoly.Vertices.size());
uint prevSize = _ClippedTris.size();
_ClippedTris.resize(_ClippedTris.size() + clipPoly.Vertices.size());
std::copy(clipPoly.Vertices.begin(), clipPoly.Vertices.end(), _ClippedTris.begin() + prevSize); // append to packed list
totalNumVertices += (clipPoly.Vertices.size() - 2) * 3;
}
}
// middle block, are not clipped, but count the number of wanted vertices
if (_Inside[k].first <= _Inside[k].second)
{
totalNumVertices += 6 * (_Inside[k].second - _Inside[k].first + 1);
}
// right clipped blocks
for (sint x = _Inside[k].second + 1; x <= border[k].second; ++x)
{
clipPoly.Vertices.resize(4);
clipPoly.Vertices[0].set((float) x, (float) (k + _MinYInside), 0.f);
clipPoly.Vertices[1].set((float) (x + 1), (float) (k + _MinYInside), 0.f);
clipPoly.Vertices[2].set((float) (x + 1), (float) (k + _MinYInside + 1), 0.f);
clipPoly.Vertices[3].set((float) x, (float) (k + _MinYInside + 1), 0.f);
clipPoly.clip(clipPlanes);
if (!clipPoly.Vertices.empty())
{
// backup result (will be unprojected later)
_ClippedTriNumVerts.push_back(clipPoly.Vertices.size());
uint prevSize = _ClippedTris.size();
_ClippedTris.resize(_ClippedTris.size() + clipPoly.Vertices.size());
std::copy(clipPoly.Vertices.begin(), clipPoly.Vertices.end(), _ClippedTris.begin() + prevSize); // append to packed list
totalNumVertices += (clipPoly.Vertices.size() - 2) * 3;
}
}
}
return totalNumVertices;
}
//***********************************************************************************************************
uint CWaterModel::fillVB(void *datas, uint startTri, IDriver &drv)
{
H_AUTO( NL3D_Water_Render );
if (drv.isWaterShaderSupported())
{
return fillVBHard(datas, startTri);
}
else
{
return fillVBSoft(datas, startTri);
}
}
static const double WATER_WAVE_SPEED = 1.7;
static const double WATER_WAVE_SCALE = 0.05;
static const double WATER_WAVE_FREQ = 0.3;
static const float WATER_WAVE_ATTEN = 0.2f;
// compute single water vertex in software mode
static
#ifndef NL_DEBUG
inline
#endif
void computeWaterVertexSoft(float px, float py, CVector &pos, CVector2f &envMapTexCoord, const CVector &camI, const CVector &camJ, const CVector &camK, float denom, double date, const CVector &camPos)
{
CVector d = px * camI + py * camK + camJ;
//nlassert(d.z > 0.f);
float intersectionDist = denom / d.z;
pos.x = intersectionDist * d.x;
pos.y = intersectionDist * d.y;
pos.z = 0.f;
//
CVector R(- pos.x,
- pos.y,
- denom
);
float dist = R.norm();
if (dist)
{
R /= dist;
}
envMapTexCoord.set(- 0.5f * R.x + 0.5f, - 0.5f * R.y + 0.5f);
if (dist)
{
float invDist = 1.f / (WATER_WAVE_ATTEN * dist);
if (invDist > 1.f) invDist = 1.f;
// TODO : optimize cos if need (for now there are not much call per frame ...)
envMapTexCoord.x += (float) (invDist * WATER_WAVE_SCALE * (float) cos(date + WATER_WAVE_FREQ * (camPos.x + pos.x)));
}
}
//***********************************************************************************************************
uint CWaterModel::fillVBSoft(void *datas, uint startTri)
{
_StartTri = (uint32) startTri;
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
const NLMISC::CMatrix &camMat = renderTrav.CamMatrix;
const sint numStepX = CWaterShape::getScreenXGridSize();
const sint numStepY = CWaterShape::getScreenYGridSize();
CVector camI = camMat.getI() * (1.f / numStepX) * (renderTrav.Right - renderTrav.Left) / renderTrav.Near;
CVector camJ = camMat.getJ();
CVector camK = camMat.getK() * (1.f / numStepY) * (renderTrav.Top - renderTrav.Bottom) / renderTrav.Near;
float obsZ = camMat.getPos().z;
float denom = getWorldMatrix().getPos().z - obsZ;
uint8 *dest = (uint8 *) datas + startTri * 3 * WATER_VERTEX_SOFT_SIZE;
/*NLMISC::CVector eye = renderTrav.CamPos;
eye.z -= getWorldMatrix().getPos().z; */
NLMISC::CVector eye(0.f, 0.f, - denom);
CVector R;
CScene *scene = getOwnerScene();
double date = WATER_WAVE_SPEED * scene->getCurrentTime();
if (!_ClippedTriNumVerts.empty())
{
const CVector2f *currVert = &_ClippedTris.front();
static std::vector<CVector> unprojectedTriSoft;
static std::vector<CVector2f> envMap;
for(uint k = 0; k < _ClippedTriNumVerts.size(); ++k)
{
unprojectedTriSoft.resize(_ClippedTriNumVerts[k]);
envMap.resize(_ClippedTriNumVerts[k]);
uint numVerts = _ClippedTriNumVerts[k];
for(uint l = 0; l < _ClippedTriNumVerts[k]; ++l)
{
computeWaterVertexSoft(currVert->x, currVert->y, unprojectedTriSoft[l], envMap[l], camI, camJ, camK, denom, date, camMat.getPos());
++ currVert;
}
for(uint l = 0; l < numVerts - 2; ++l)
{
*(CVector *) dest = unprojectedTriSoft[0];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[0];
dest += sizeof(float[2]);
*(CVector *) dest = unprojectedTriSoft[l + 1];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[l + 1];
dest += sizeof(float[2]);
*(CVector *) dest = unprojectedTriSoft[l + 2];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[l + 2];
dest += sizeof(float[2]);
}
}
}
// TODO : optimize if needed
for(sint k = 0; k < (sint) _Inside.size(); ++k)
{
sint y = k + _MinYInside;
CVector proj[4];
CVector2f envMap[4];
if (_Inside[k].first <= _Inside[k].second)
{
// middle block, are not clipped, but count the number of wanted vertices
for(sint x = _Inside[k].first; x <= _Inside[k].second; ++x)
{
computeWaterVertexSoft((float) x, (float) y, proj[0], envMap[0], camI, camJ, camK, denom, date, camMat.getPos());
computeWaterVertexSoft((float)(x + 1), (float) y, proj[1], envMap[1], camI, camJ, camK, denom, date, camMat.getPos());
computeWaterVertexSoft((float) (x + 1), (float) (y + 1), proj[2], envMap[2], camI, camJ, camK, denom, date, camMat.getPos());
computeWaterVertexSoft((float) x, (float) (y + 1), proj[3], envMap[3], camI, camJ, camK, denom, date, camMat.getPos());
//
*(CVector *) dest = proj[0];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[0];
dest += sizeof(float[2]);
*(CVector *) dest = proj[2];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[2];
dest += sizeof(float[2]);
*(CVector *) dest = proj[1];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[1];
dest += sizeof(float[2]);
*(CVector *) dest = proj[0];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[0];
dest += sizeof(float[2]);
*(CVector *) dest = proj[3];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[3];
dest += sizeof(float[2]);
*(CVector *) dest = proj[2];
dest += sizeof(float[3]);
*(CVector2f *) dest = envMap[2];
dest += sizeof(float[2]);
}
}
}
nlassert((dest - (uint8 * ) datas) % (3 * WATER_VERTEX_SOFT_SIZE) == 0);
uint endTri = (dest - (uint8 * ) datas) / (3 * WATER_VERTEX_SOFT_SIZE);
_NumTris = endTri - _StartTri;
return endTri;
}
// compute single water vertex for hardware render
static
#ifndef NL_DEBUG
inline
#endif
void computeWaterVertexHard(float px, float py, CVector &pos, const CVector &camI, const CVector &camJ, const CVector &camK, float denom)
{
CVector d = px * camI + py * camK + camJ;
float intersectionDist = denom / d.z;
pos.x = intersectionDist * d.x;
pos.y = intersectionDist * d.y;
pos.z = 0.f;
}
//***********************************************************************************************************
uint CWaterModel::fillVBHard(void *datas, uint startTri)
{
_StartTri = (uint32) startTri;
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
const NLMISC::CMatrix &camMat = renderTrav.CamMatrix;
const sint numStepX = CWaterShape::getScreenXGridSize();
const sint numStepY = CWaterShape::getScreenYGridSize();
CVector camI = camMat.getI() * (1.f / numStepX) * (renderTrav.Right - renderTrav.Left) / renderTrav.Near;
CVector camJ = camMat.getJ();
CVector camK = camMat.getK() * (1.f / numStepY) * (renderTrav.Top - renderTrav.Bottom) / renderTrav.Near;
float obsZ = camMat.getPos().z;
float denom = getWorldMatrix().getPos().z - obsZ;
uint8 *dest = (uint8 *) datas + startTri * WATER_VERTEX_HARD_SIZE * 3;
if (!_ClippedTriNumVerts.empty())
{
const CVector2f *currVert = &_ClippedTris.front();
static std::vector<CVector> unprojectedTri;
for(uint k = 0; k < _ClippedTriNumVerts.size(); ++k)
{
unprojectedTri.resize(_ClippedTriNumVerts[k]);
uint numVerts = _ClippedTriNumVerts[k];
for(uint l = 0; l < _ClippedTriNumVerts[k]; ++l)
{
computeWaterVertexHard(currVert->x, currVert->y, unprojectedTri[l], camI, camJ, camK, denom);
++ currVert;
}
for(uint l = 0; l < numVerts - 2; ++l)
{
*(CVector *) dest = unprojectedTri[0];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = unprojectedTri[l + 1];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = unprojectedTri[l + 2];
dest += WATER_VERTEX_HARD_SIZE;
}
}
}
// TODO : optimize if needed
for(sint k = 0; k < (sint) _Inside.size(); ++k)
{
sint y = k + _MinYInside;
CVector proj[4];
if (_Inside[k].first <= _Inside[k].second)
{
// middle block, are not clipped, but count the number of wanted vertices
for(sint x = _Inside[k].first; x <= _Inside[k].second; ++x)
{
computeWaterVertexHard((float) x, (float) y, proj[0], camI, camJ, camK, denom);
computeWaterVertexHard((float) (x + 1), (float) y, proj[1], camI, camJ, camK, denom);
computeWaterVertexHard((float) (x + 1), (float) (y + 1), proj[2], camI, camJ, camK, denom);
computeWaterVertexHard((float) x, (float) (y + 1), proj[3], camI, camJ, camK, denom);
//
*(CVector *) dest = proj[0];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = proj[2];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = proj[1];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = proj[0];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = proj[3];
dest += WATER_VERTEX_HARD_SIZE;
*(CVector *) dest = proj[2];
dest += WATER_VERTEX_HARD_SIZE;
}
}
}
nlassert((dest - (uint8 * ) datas) % (3 * WATER_VERTEX_HARD_SIZE) == 0);
uint endTri = (dest - (uint8 * ) datas) / (3 * WATER_VERTEX_HARD_SIZE);
_NumTris = endTri - _StartTri;
return endTri;
}
//***************************************************************************************************************
void CWaterModel::traverseRender()
{
H_AUTO( NL3D_Water_Render );
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
IDriver *drv = renderTrav.getDriver();
CWaterShape *shape = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
const NLMISC::CVector &obsPos = renderTrav.CamPos;
const float zHeight = getWorldMatrix().getPos().z;
if (!renderTrav.Perspective || forceWaterSimpleRender)
{
// not supported, simple uniform render
drv->setupModelMatrix(getWorldMatrix());
static CMaterial waterMat;
static bool initDone = false;
if (!initDone)
{
waterMat.initUnlit();
waterMat.setBlend(true);
waterMat.setSrcBlend(CMaterial::srcalpha);
waterMat.setDstBlend(CMaterial::invsrcalpha);
waterMat.setBlend(true);
waterMat.setDoubleSided(true);
waterMat.setLighting(false);
}
waterMat.setColor(shape->computeEnvMapMeanColor());
static std::vector<NLMISC::CTriangleUV> tris;
const NLMISC::CPolygon2D &poly = shape->getShape();
tris.clear();
for(sint k = 0; k < (sint) poly.Vertices.size() - 2; ++k)
{
NLMISC::CTriangleUV truv;
truv.V0.set(poly.Vertices[0].x, poly.Vertices[0].y, 0.f);
truv.V1.set(poly.Vertices[k + 1].x, poly.Vertices[k + 1].y, 0.f);
truv.V2.set(poly.Vertices[k + 2].x, poly.Vertices[k + 2].y, 0.f);
tris.push_back(truv);
}
CDRU::drawTrianglesUnlit(tris, waterMat, *drv);
}
else
{
NLMISC::CMatrix modelMat;
modelMat.setPos(NLMISC::CVector(obsPos.x, obsPos.y, zHeight));
drv->setupModelMatrix(modelMat);
bool isAbove = obsPos.z > getWorldMatrix().getPos().z;
CVertexBuffer &vb = renderTrav.Scene->getWaterVB();
if (drv->isWaterShaderSupported())
{
setupMaterialNVertexShader(drv, shape, obsPos, isAbove, zHeight);
nlassert(vb.getNumVertices() > 0);
drv->activeVertexBuffer(vb);
drv->renderRawTriangles(CWaterModel::_WaterMat, _StartTri, _NumTris);
drv->activeVertexProgram(NULL);
}
else
{
setupSimpleRender(shape, obsPos, isAbove);
drv->activeVertexBuffer(vb);
drv->activeVertexProgram(NULL);
drv->renderRawTriangles(CWaterModel::_SimpleWaterMat, _StartTri, _NumTris);
}
}
}
//***********************************************************************************************************
bool CWaterModel::clip()
{
H_AUTO( NL3D_Water_Render );
CRenderTrav &renderTrav= getOwnerScene()->getRenderTrav();
if (renderTrav.CamPos.z == getWorldMatrix().getPos().z) return false;
if(Shape)
{
computeClippedPoly();
if (_ClippedPoly.Vertices.empty()) return false;
// unlink from water model list
unlink();
// link into water model list
link();
return true;
}
else
return false;
}
/*
// struct used to build vertices for the simple shader
struct CSimpleVertexInfo
{
NLMISC::CVector XFormPos;
NLMISC::CUV UV;
};
*/
//***********************************************************************************************************
/*
void CWaterModel::doSimpleRender(IDriver *drv)
{
if (_ClippedPoly.Vertices.empty()) return;
// rendering of water when no vertex / pixel shaders are available
CWaterShape *shape = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
static bool init = false;
if (!init)
{
// setup the material, no special shader is used here
_SimpleWaterMat.setLighting(false);
_SimpleWaterMat.setDoubleSided(true);
_SimpleWaterMat.setColor(NLMISC::CRGBA::White);
_SimpleWaterMat.setBlend(true);
_SimpleWaterMat.setSrcBlend(CMaterial::srcalpha);
_SimpleWaterMat.setDstBlend(CMaterial::invsrcalpha);
_SimpleWaterMat.setZWrite(true);
_SimpleWaterMat.setShader(CMaterial::Normal);
// stage 0
_SimpleWaterMat.texEnvOpRGB(0, CMaterial::Replace);
_SimpleWaterMat.texEnvOpAlpha(0, CMaterial::Replace);
_SimpleWaterMat.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
// stage 1
_SimpleWaterMat.texEnvOpRGB(1, CMaterial::Modulate);
_SimpleWaterMat.texEnvOpAlpha(1, CMaterial::Modulate);
_SimpleWaterMat.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
_SimpleWaterMat.texEnvArg1RGB(0, CMaterial::Previous, CMaterial::SrcColor);
_SimpleWaterMat.texEnvArg1Alpha(0, CMaterial::Previous, CMaterial::SrcAlpha);
// setup the vb : one position & two tex coords
_SimpleRenderVB.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag | CVertexBuffer::TexCoord1Flag);
init = true;
}
const NLMISC::CMatrix &worldMatrix = getWorldMatrix();
const NLMISC::CVector &obsPos = renderTrav.CamPos;
// setup the material
bool isAbove = obsPos.z > worldMatrix.getPos().z;
// envmap is always present and is in stage 0
CScene *scene = getOwnerScene();
if (!isAbove && shape->_EnvMap[1])
{
if (shape->_UsesSceneWaterEnvMap[1])
{
if (scene->getWaterEnvMap())
{
_SimpleWaterMat.setTexture(0, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[1]);
}
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[1]);
}
}
else
{
if (shape->_UsesSceneWaterEnvMap[0])
{
if (scene->getWaterEnvMap())
{
_SimpleWaterMat.setTexture(0, scene->getWaterEnvMap()->getEnvMap2D());
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[0]);
}
}
else
{
_SimpleWaterMat.setTexture(0, shape->_EnvMap[0]);
}
}
//
static std::vector<CSimpleVertexInfo> verts;
static CIndexBuffer indices;
//
NLMISC::CPolygon2D &poly = shape->_Poly;
uint numVerts = poly.Vertices.size();
uint k;
//
if (shape->_ColorMap == NULL)
{
// version with no color map
if (!_EmbossTexture)
{
_EmbossTexture = new CTextureEmboss;
_EmbossTexture->setSlopeFactor(4.f);
}
if (shape->_BumpMap[1] && shape->_BumpMap[1]->isBumpMap())
{
CTextureBump *bm = static_cast<CTextureBump *>((ITexture *) shape->_BumpMap[1]);
if (bm->getHeightMap())
{
_EmbossTexture->setHeightMap(bm->getHeightMap());
}
}
_SimpleWaterMat.setTexture(1, _EmbossTexture);
_SimpleRenderVB.setNumVertices(numVerts);
// retrieve current time
float date = 0.001f * (NLMISC::CTime::getLocalTime() & 0xffffff); // must keep some precision.
// Compute tex coordinates for emboss first.
// On some 3D chip, textures coords can't grow too mush or texture filtering loose accuracy.
// So we must keep texCoord as low as possible.
//
verts.resize(numVerts);
for(k = 0; k < numVerts; ++k)
{
verts[k].XFormPos = worldMatrix * NLMISC::CVector(poly.Vertices[k].x, poly.Vertices[k].y ,0.f);
verts[k].UV.U = shape->_HeightMapScale[0].x * verts[k].XFormPos.x + date * shape->_HeightMapSpeed[0].x;
verts[k].UV.V = shape->_HeightMapScale[0].y * verts[k].XFormPos.y + date * shape->_HeightMapSpeed[0].y;
}
// get min tex coords
float minU = verts[0].UV.U;
float minV = verts[0].UV.V;
for(k = 1; k < numVerts; ++k)
{
minU = std::min(minU, verts[k].UV.U);
minV = std::min(minV, verts[k].UV.V);
}
//
minU = floorf(minU);
minV = floorf(minV);
//
CVertexBufferReadWrite vba;
_SimpleRenderVB.lock (vba);
uint8 *data = (uint8 *) vba.getVertexCoordPointer();
for(k = 0; k < numVerts; ++k)
{
((NLMISC::CVector *) data)->set(poly.Vertices[k].x, poly.Vertices[k].y, 0.f);
data += sizeof(NLMISC::CVector);
// texture coord 0 is reflected vector into envmap
// xform position in world space to compute the reflection
CVector surfToEye = (obsPos - verts[k].XFormPos).normed();
// we assume that normal is (0, 0, 1)
* (float *) data = 0.5f - 0.5f * surfToEye.x;
((float *) data)[1] = 0.5f - 0.5f * surfToEye.y;
data += sizeof(float[2]);
// texture coord 1 is the embossed map
* (float *) data = verts[k].UV.U - minU;
((float *) data)[1] = verts[k].UV.V - minV;
data += sizeof(float[2]);
}
}
else
{
// version with a color map : it remplace the emboss texture
_SimpleWaterMat.setTexture(1, shape->_ColorMap);
_SimpleRenderVB.setNumVertices(numVerts);
CVertexBufferReadWrite vba;
_SimpleRenderVB.lock (vba);
//
uint8 *data = (uint8 *) vba.getVertexCoordPointer();
for(k = 0; k < numVerts; ++k)
{
* (NLMISC::CVector *) data = poly.Vertices[k];
data += sizeof(CVector);
// texture coord 0 is reflected vector into envmap
// xform position in world space to compute the reflection
NLMISC::CVector xformPos = worldMatrix * poly.Vertices[k];
NLMISC::CVector surfToEye = (obsPos - xformPos).normed();
// we assume that normal is (0, 0, 1)
* (float *) data = 0.5f - 0.5f * surfToEye.x;
((float *) data)[1] = 0.5f * - 0.5f * surfToEye.y;
data += sizeof(float[2]);
// texture coord 1 is the color map
* (float *) data = shape->_ColorMapMatColumn0.x * xformPos.x + shape->_ColorMapMatColumn1.x * xformPos.y + shape->_ColorMapMatPos.x;
((float *) data)[1] = shape->_ColorMapMatColumn0.y * xformPos.x + shape->_ColorMapMatColumn1.y * xformPos.y + shape->_ColorMapMatPos.y;
data += sizeof(float[2]);
}
}
drv->activeVertexProgram(NULL);
drv->setupModelMatrix(worldMatrix);
drv->activeVertexBuffer(_SimpleRenderVB);
// create an index buffer to do the display
indices.setNumIndexes((numVerts - 2) * 3);
{
CIndexBufferReadWrite ibaWrite;
indices.lock (ibaWrite);
uint32 *ptr = ibaWrite.getPtr();
for(k = 0; k < (numVerts - 2); ++k)
{
ptr[ k * 3 ] = 0;
ptr[ k * 3 + 1 ] = k + 1;
ptr[ k * 3 + 2 ] = k + 2;
}
}
drv->setupMaterial(_SimpleWaterMat);
drv->activeIndexBuffer(indices);
drv->renderSimpleTriangles(0, numVerts - 2);
}
*/
//***********************************************************************************************************
void CWaterModel::updateDiffuseMapMatrix(bool force /* = false*/)
{
if (compareMatrixDate(_MatrixUpdateDate) ||force)
{
CWaterShape *shape = NLMISC::safe_cast<CWaterShape *>((IShape *) Shape);
if (shape)
{
_MatrixUpdateDate = getMatrixDate();
// update the uv matrix
CMatrix uvMat;
uvMat.setRot(CVector(shape->_ColorMapMatColumn0.x, shape->_ColorMapMatColumn0.y, 0.f),
CVector(shape->_ColorMapMatColumn1.x, shape->_ColorMapMatColumn1.y, 0.f),
CVector(shape->_ColorMapMatPos.x, shape->_ColorMapMatPos.y, 1.f));
CMatrix xformMat;
CMatrix invMat = this->getWorldMatrix().inverted();
xformMat.setRot(CVector(invMat.getI().x, invMat.getI().y, 0.f),
CVector(invMat.getJ().x, invMat.getJ().y, 0.f),
CVector(invMat.getPos().x, invMat.getPos().y, 1.f));
uvMat = uvMat * xformMat;
_ColorMapMatColumn0.set(uvMat.getI().x, uvMat.getI().y);
_ColorMapMatColumn1.set(uvMat.getJ().x, uvMat.getJ().y);
_ColorMapMatPos.set(uvMat.getK().x, uvMat.getK().y);
}
}
}
// ***************************************************************************
void CWaterModel::debugDumpMem(void* &clippedPolyBegin, void* &clippedPolyEnd)
{
clippedPolyBegin= (void*)(&*_ClippedPoly.Vertices.begin());
clippedPolyEnd= (void*)(&*_ClippedPoly.Vertices.end());
}
// ***************************************************************************
void CWaterModel::debugClearClippedPoly()
{
_ClippedPoly.Vertices.clear();
}
//=======================================================================================
// wave maker implementation
//=======================================================================================
CWaveMakerModel::CWaveMakerModel() : _Time(0)
{
// AnimDetail behavior: Must be traversed in AnimDetail, even if no channel mixer registered
CTransform::setIsForceAnimDetail(true);
}
//================================================
void CWaveMakerModel::registerBasic()
{
CScene::registerModel(WaveMakerModelClassId, TransformShapeId, CWaveMakerModel::creator);
}
//================================================
ITrack* CWaveMakerModel::getDefaultTrack (uint valueId)
{
nlassert(Shape);
CWaveMakerShape *ws = NLMISC::safe_cast<CWaveMakerShape *>((IShape *) Shape);
switch (valueId)
{
case PosValue: return ws->getDefaultPos(); break;
default: // delegate to parent
return CTransformShape::getDefaultTrack(valueId);
break;
}
}
//================================================
void CWaveMakerModel::traverseAnimDetail()
{
CTransformShape::traverseAnimDetail();
nlassert(getOwnerScene());
/// get the shape
CWaveMakerShape *wms = NLMISC::safe_cast<CWaveMakerShape *>((IShape *) Shape);
const NLMISC::CVector worldPos = getWorldMatrix().getPos();
const CVector2f pos2d(worldPos.x, worldPos.y);
/// get the water height map
CWaterHeightMap &whm = GetWaterPoolManager().getPoolByID(wms->_PoolID);
// get the time delta
const TAnimationTime deltaT = std::min(getOwnerScene()->getEllapsedTime(), (TAnimationTime) whm.getPropagationTime());
_Time += deltaT;
if (!wms->_ImpulsionMode)
{
whm.perturbate(pos2d, wms->_Intensity * cosf(2.f / wms->_Period * (float) NLMISC::Pi * _Time), wms->_Radius);
}
else
{
if (_Time > wms->_Period)
{
_Time -= wms->_Period;
whm.perturbate(pos2d, wms->_Intensity, wms->_Radius);
}
}
}
} // NL3D
Reference in a new issue Copy permalink