Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/client/src/micro_life_manager.cpp

997 lines
34 KiB
C++
Raw Normal View History

Changed: order or the lib to make it compile in pure static
2010-07-28 06:57:08 +00:00
// 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 "micro_life_manager.h"
#include "sheet_manager.h"
#include "misc.h"
#include "continent_manager.h"
#include "user_entity.h"
#include "weather.h"
#include "water_map.h"
//
#include "client_sheets/flora_sheet.h"
//
#include "nel/misc/polygon.h"
#include "nel/misc/bitmap.h"
#include "nel/misc/file.h"
#include "nel/misc/i_xml.h"
#include "nel/misc/line.h"
//
#include "nel/ligo/primitive.h"
//
#include "nel/3d/u_landscape.h"
#include "nel/3d/u_material.h"
#include "nel/3d/u_driver.h"
#include "nel/3d/u_scene.h"
//
#include "nel/misc/check_fpu.h"
using namespace std::rel_ops;
extern NLLIGO::CLigoConfig LigoConfig;
extern CContinentManager ContinentMngr;
extern NL3D::ULandscape *Landscape;
extern NL3D::UDriver *Driver;
extern NL3D::UScene *Scene;
extern CUserEntity *Userentity;
extern NL3D::UMaterial GenericMat;
#if !FINAL_VERSION
bool DisplayMicroLifeZones = false;
#endif
#ifdef NL_DEBUG
extern bool DisplayMicroLifeActiveTiles = false;
#endif
H_AUTO_DECL(RZ_MicroLifeManager)
// ********************************************************************************************
CMicroLifeManager::CMicroLifeManager()
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
_CellSize = 0.f;
_GridWidth = 0;
_GridHeight = 0;
_Noise.Abs = 0.f;
_Noise.Rand = 1.f;
}
// ********************************************************************************************
CMicroLifeManager &CMicroLifeManager::getInstance()
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
static CMicroLifeManager instance;
return instance;
}
// ********************************************************************************************
void CMicroLifeManager::init(const NLMISC::CVector2f &minCorner, const NLMISC::CVector2f &maxCorner, float cellSize /* = 30.f*/)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
release();
if (!Landscape) return;
Landscape->addTileCallback(this);
if (cellSize == 0.f)
{
nlwarning("Bad cell size");
return;
}
if (minCorner.x >= maxCorner.x)
{
nlwarning("Corners not well ordered");
return;
}
_CellSize = cellSize;
//
NLMISC::CVector2f minCornerFinal = minCorner;
NLMISC::CVector2f maxCornerFinal = maxCorner;
if (minCornerFinal.x > maxCornerFinal.x) std::swap(minCornerFinal.x, maxCornerFinal.x);
if (minCornerFinal.y > maxCornerFinal.y) std::swap(minCornerFinal.y, maxCornerFinal.y);
//
_GridWidth = (uint) (floorf(maxCornerFinal.x - minCornerFinal.x) / cellSize);
_GridHeight = (uint) (floorf(maxCornerFinal.y - minCornerFinal.y) / cellSize);
_MinCorner = minCornerFinal;
_Grid.resize(_GridWidth * _GridHeight, 0);
_Noise.Frequency = 10.1346541f / cellSize;
}
///////////////////
// BUILD PROCESS //
///////////////////
// To quickly know if a tile is inside a zone of micro-life, we subdivide the world into a grid. Each grid cell
// may be overlapped by [0, n] polygons of a micro-life zone. We don't want to store a full list for each cell of
// the grid, because such lists are repeated several times (it would end up wasting too much space). What we just need to keep is
// a set of possible polygon lists that can overlap a grid cell. Afterward, we just need a grid of index into
// the list of possible polygon lists.
// To do that : - we first store complete lists in each grid cells : this is done by several calls to drawPolyInBuildGrid
// - we search for redundant lists and store the result as index in the final grid. This is done in packBuildGrid
// *********************************************************************************************************************************
bool CMicroLifeManager::CGridOverlapPolyInfo::operator < (const CMicroLifeManager::CGridOverlapPolyInfo &other) const
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (PrimitiveIndex != other.PrimitiveIndex) return PrimitiveIndex < other.PrimitiveIndex;
if (Sheet != other.Sheet) return Sheet < other.Sheet;
if (IsExcludePoly != other.IsExcludePoly) return !other.IsExcludePoly; // want to test exclude polys first
if (IsFullyCovered != other.IsFullyCovered) return other.IsFullyCovered;
return Poly < other.Poly;
}
// *********************************************************************************************************************************
bool CMicroLifeManager::CGridOverlapPolyInfo::operator == (const CMicroLifeManager::CGridOverlapPolyInfo &other) const
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
return PrimitiveIndex == other.PrimitiveIndex &&
Sheet == other.Sheet &&
IsExcludePoly == other.IsExcludePoly &&
IsFullyCovered == other.IsFullyCovered &&
Poly == other.Poly;
}
// *********************************************************************************************************************************
bool CMicroLifeManager::CGridOverlapPolyInfoVector::operator < (const CMicroLifeManager::CGridOverlapPolyInfoVector &other) const
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (V.size() != other.V.size()) return V.size() < other.V.size();
for(uint k = 0; k < V.size(); ++k)
{
if (V[k] != other.V[k]) return V[k] < other.V[k];
}
return false;
}
// *********************************************************************************************************************************
bool CMicroLifeManager::CGridOverlapPolyInfoVector::operator == (const CMicroLifeManager::CGridOverlapPolyInfoVector &other) const
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (V.size() != other.V.size()) return false;
return std::equal(V.begin(), V.end(), other.V.begin());
}
// ***************************************************************************************************************************
void CMicroLifeManager::drawPolyInBuildGrid(const std::vector<NLLIGO::CPrimVector> &primPoly,
uint primitiveIndex,
CMicroLifeManager::TBuildGrid &buildGrid,
const CFloraSheet *sheet,
bool isExcludeTri)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
NLMISC::CPolygon poly;
poly.Vertices.resize(primPoly.size());
std::copy(primPoly.begin(), primPoly.end(), poly.Vertices.begin());
std::list<NLMISC::CPolygon> convexPolys;
if (!poly.toConvexPolygons(convexPolys, NLMISC::CMatrix::Identity))
{
nlwarning("Can't convert to convex polys");
return;
}
NLMISC::CPolygon2D poly2D;
for(std::list<NLMISC::CPolygon>::iterator it = convexPolys.begin(); it != convexPolys.end(); ++it)
{
poly2D.Vertices.resize(it->Vertices.size());
// convert poly in cell units
for(uint k = 0; k < it->Vertices.size(); ++k)
{
poly2D.Vertices[k].x = (it->Vertices[k].x - _MinCorner.x) / _CellSize;
poly2D.Vertices[k].y = (it->Vertices[k].y - _MinCorner.y) / _CellSize;
//nlinfo("poly2D.Vertices[k].x = %.1f, poly2D.Vertices[k].y = %.1f", poly2D.Vertices[k].x, poly2D.Vertices[k].y);
}
// rasterize poly
NLMISC::CPolygon2D::TRasterVect outerBorders;
NLMISC::CPolygon2D::TRasterVect innerBorders;
sint outerMinY;
sint innerMinY;
poly2D.computeOuterBorders(outerBorders, outerMinY);
poly2D.computeInnerBorders(innerBorders, innerMinY);
if (outerBorders.empty()) continue; // no contribution for that poly
CGridOverlapPolyInfo gti;
gti.IsExcludePoly = isExcludeTri;
gti.Sheet = sheet;
gti.Poly = *it;
gti.PrimitiveIndex = primitiveIndex;
sint maxY = std::min(outerMinY + (sint)outerBorders.size(), (sint)_GridHeight);
sint startY = std::max(0, outerMinY);
for (sint y = startY; y < maxY; ++y)
{
sint maxX = std::min(outerBorders[y - startY].second, (sint) (_GridWidth - 1));
for (sint x = std::max((sint) 0, outerBorders[y - startY].first); x <= maxX; ++x)
{
nlassert(x >= 0);
nlassert(y >= 0);
nlassert(x < (sint) _GridWidth);
nlassert(y < (sint) _GridHeight);
gti.IsFullyCovered = false;
// see if primitive covers entirely this grid cell
if (y >= innerMinY && y < innerMinY + (sint) innerBorders.size())
{
if (x >= innerBorders[y - innerMinY].first && x <= innerBorders[y - innerMinY].second)
{
gti.IsFullyCovered = true;
}
}
buildGrid[x + y * _GridWidth].V.push_back(gti);
}
}
}
}
// predicate to remove a cell that is fully covered by an exclude poly
class CCleanFullyCoveredGridCellPred
{
public:
uint PrimitiveIndex;
public:
bool operator()(const CMicroLifeManager::CGridOverlapPolyInfo &info) const
{
FPU_CHECKER
return info.PrimitiveIndex == PrimitiveIndex;
}
};
// ***************************************************************************************************************************
// pack the build grid so that each cell only contains index into a small set of poly list, instead of a full poly list
// (a lot of cells share the same poly list)
void CMicroLifeManager::packBuildGrid(TBuildGrid &buildGrid,
CMicroLifeManager::TPossibleOverlapingPolyLists &finalPossibleLists
)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
// the already possible lists
std::set<CGridOverlapPolyInfoVector> possibleLists;
// for each cell : - remove all polys of the same zone if there's an exclude tri that covers the whole grid
// - compute the set of possible lists
for(uint k = 0; k < buildGrid.size(); ++k)
{
CGridOverlapPolyInfoVector &gopiv = buildGrid[k];
bool restart = false;
do
{
restart = false;
for(std::vector<CGridOverlapPolyInfo>::iterator it = gopiv.V.begin(); it != gopiv.V.end(); ++it)
{
if (it->IsExcludePoly && it->IsFullyCovered)
{
// remove everything about that primitive
CCleanFullyCoveredGridCellPred pred;
pred.PrimitiveIndex = it->PrimitiveIndex;
gopiv.V.erase(std::remove_if(gopiv.V.begin(), gopiv.V.end(), pred), gopiv.V.end());
restart = true; // must restart scan from start of list because iterator is now invalid
break;
}
}
}
while (restart);
// insert in possible lists
possibleLists.insert(gopiv);
}
// second pass : flatten the set of possible lists to build an index for each grid cell
nlassert(possibleLists.size() <= 65536);
TPossibleOverlapingPolyLists flatSet(possibleLists.size());
std::copy(possibleLists.begin(), possibleLists.end(), flatSet.begin());
_Grid.resize(buildGrid.size());
for(uint k = 0; k < buildGrid.size(); ++k)
{
TPossibleOverlapingPolyLists::const_iterator it = std::lower_bound(flatSet.begin(), flatSet.end(), buildGrid[k]);
nlassert(it != flatSet.end());
nlassert(*it == buildGrid[k]);
_Grid[k] = (uint16) (it - flatSet.begin());
}
finalPossibleLists.swap(flatSet);
}
// ***************************************************************************************************************************
// read a .primitive file and add its content to a build grid
void CMicroLifeManager::addPrimitiveToBuildGrid(const std::string &fileName, uint &primitiveIndex, CMicroLifeManager::TBuildGrid &buildGrid)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
// read the file into memory and parse to generate 'prims' data tree
NLLIGO::CPrimitives prims;
NLMISC::CIFile fileIn;
std::string path = NLMISC::CPath::lookup(fileName, false, true);
if (path.empty()) return;
if (!fileIn.open (path))
{
nlwarning("Can't open %s", path.c_str());
return;
}
// Xml stream
NLMISC::CIXml xmlIn;
xmlIn.init (fileIn);
// Read it
if (!prims.read(xmlIn.getRootNode(), path.c_str(), LigoConfig))
{
nlwarning ("Error reading file %s", path.c_str());
return;
}
// get each son zone
for(uint k = 0; k < prims.RootNode->getNumChildren(); ++k)
{
NLLIGO::IPrimitive *child;
if (!(prims.RootNode->getChild(child, k) && child)) continue;
//
std::string className;
// make sure it is a 'micro_life' primitive
if (!child->getPropertyByName("class", className))
{
nlwarning("Can't get class for child %d of primitive %s", (int) k, path.c_str());
continue;
}
if (NLMISC::nlstricmp(className.c_str(), "micro_life") != 0) continue; // only deals with micro life
// read flora sheet in the primitive
std::string formName;
if (!child->getPropertyByName("form", formName))
{
nlwarning("Can't get form name for child %d of primitive %s", (int) k, path.c_str());
continue;
}
const CEntitySheet *sheet = SheetMngr.get(NLMISC::CSheetId(formName));
if (!sheet)
{
nlwarning("Can't get sheet %s", formName.c_str());
continue;
}
const CFloraSheet *floraSheet = dynamic_cast<const CFloraSheet *>(sheet);
if (!floraSheet)
{
nlwarning("Sheet %s has bad type. Flora sheet wanted", formName.c_str());
continue;
}
//
for(uint m = 0; m < child->getNumChildren(); ++m)
{
NLLIGO::IPrimitive *mlZone;
if (!(child->getChild(mlZone, m) && mlZone)) continue;
// make sure it is a 'micro_life_zone'
if (!mlZone->getPropertyByName("class", className))
{
nlwarning("Can't get class for child %d of primitive %s", (int) m, path.c_str());
continue;
}
if (NLMISC::nlstricmp("micro_life_zone", className) != 0) continue;
NLLIGO::CPrimZone *zone = dynamic_cast<NLLIGO::CPrimZone *>(mlZone);
if (!zone)
{
nlwarning("Child %d of primitive %s is not a zone", (int) k, path.c_str());
continue;
}
drawPolyInBuildGrid(zone->VPoints, primitiveIndex, buildGrid, floraSheet, false);
// remove exlcusion zones
for(uint l = 0; l < zone->getNumChildren(); ++l)
{
NLLIGO::IPrimitive *exclPrim;
if (zone->getChild(exclPrim, l) && exclPrim)
{
if (!exclPrim->getPropertyByName("class", className))
{
nlwarning("Can't get class of sub-zone %d for child %d of primitive %s", (int) l, (int) m, path.c_str());
continue;
}
}
if (NLMISC::nlstricmp("micro_life_exclude_zone", className) == 0)
{
NLLIGO::CPrimZone *exclZone = dynamic_cast<NLLIGO::CPrimZone *>(exclPrim);
if (!zone)
{
nlwarning("Child %d of child %d of primitive %s is not a zone", (int) l, (int) m, path.c_str());
continue;
}
// draw exclude polygon
drawPolyInBuildGrid(exclZone->VPoints, primitiveIndex, buildGrid, floraSheet, true);
}
}
++ primitiveIndex;
}
}
}
// ********************************************************************************************
void CMicroLifeManager::build(const std::vector<std::string> &fileNames)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
TBuildGrid buildGrid;
buildGrid.resize(_Grid.size());
uint currPrimitiveIndex = 0;
for(uint l = 0; l < fileNames.size(); ++l)
{
addPrimitiveToBuildGrid(fileNames[l], currPrimitiveIndex, buildGrid);
}
// build the final grid
packBuildGrid(buildGrid, _PossibleOverlapPolyLists);
}
// ********************************************************************************************
void CMicroLifeManager::release()
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (Landscape)
{
if (Landscape->isTileCallback(this))
{
Landscape->removeTileCallback(this);
}
}
// release all registered fxs
for(TTileIDToFX::iterator it = _ActiveFXs.begin(); it != _ActiveFXs.end(); ++it)
{
CTimedFXManager::getInstance().remove(it->second);
}
_ActiveFXs.clear();
NLMISC::contReset(_Grid);
NLMISC::contReset(_PossibleOverlapPolyLists);
#ifdef NL_DEBUG
_ActiveTiles.clear();
_ActiveTilesWithFX.clear();
#endif
}
// ********************************************************************************************
void CMicroLifeManager::tileAdded(const NL3D::CTileAddedInfo &infos)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (_CellSize == 0.f) return; // not initialized
#ifdef NL_DEBUG
_ActiveTiles[infos.TileID] = infos;
#endif
// get coords in grid
sint gridCoordX = (sint) floorf((infos.Center.x - _MinCorner.x) / _CellSize);
if (gridCoordX < 0 || gridCoordX >= (sint) _GridWidth) return;
sint gridCoordY = (sint) floorf((infos.Center.y - _MinCorner.y) / _CellSize);
if (gridCoordY < 0 || gridCoordY >= (sint) _GridHeight) return;
// get list of primitives over which the center of the tile is
if( _PossibleOverlapPolyLists.empty() )
return; // AJM for when called during zone destructor
const CGridOverlapPolyInfoVector &iv = _PossibleOverlapPolyLists[_Grid[gridCoordX + gridCoordY * _GridWidth]];
if (iv.V.empty()) return;
static std::vector<CTimedFX> fxToSpawn; // static for fast alloc
fxToSpawn.clear();
uint k = 0;
do
{
const CFloraSheet *fs = iv.V[k].Sheet;
if (!fs) continue;
if (fs->getNumPlantInfos() == 0) continue;
//
bool inside = false;
uint currPrimIndex = iv.V[k].PrimitiveIndex;
do
{
if (iv.V[k].IsExcludePoly)
{
// test if center of tile is inside of the primitive
if (iv.V[k].Poly.contains(NLMISC::CVector2f(infos.Center.x, infos.Center.y)))
{
inside = false;
// jump to next primitive
for(;;)
{
if (k == iv.V.size()) break;
if (iv.V[k].PrimitiveIndex != currPrimIndex) break;
++ k;
}
break;
}
}
else
{
if (iv.V[k].IsFullyCovered)
{
// the primitive covers the whole cell so we are inside
inside = true;
}
else
{
// test is center of tile is inside
if (iv.V[k].Poly.contains(NLMISC::CVector2f(infos.Center.x, infos.Center.y)))
{
inside = true;
}
}
}
++k;
if (k == iv.V.size()) break;
}
while(iv.V[k].PrimitiveIndex == currPrimIndex);
if (!inside) continue; // no inside this primitive, try the next
// Compute noise at center of the tile, and if it is over the micro-life threshold, then spawn a fx
// To avoid that each kind of primitive be created at the same time, add an abitrary bias to the position for each primitive type
float noise = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.2564f * NLMISC::CVector::K);
if (noise > fs->MicroLifeThreshold)
{
// choose a category of plant/microlife to instanciate by computing some noise around
float mlCategory = computeUniformNoise(_Noise, infos.Center + (float) (k + 1) * _CellSize * 1.254f * NLMISC::CVector::J + 1.421f * NLMISC::CVector::I);
uint64 plantWeightedIndex = (uint64) ((double) mlCategory * fs->getPlantInfoTotalWeight());
const CPlantInfo *pi = fs->getPlantInfoFromWeightedIndex(plantWeightedIndex);
if (!pi) continue;
// get pointer on .plant from sheet
CEntitySheet *es = SheetMngr.get(NLMISC::CSheetId(pi->SheetName));
if (!es) continue;
if (es->Type != CEntitySheet::PLANT) continue;
CPlantSheet *fs = static_cast<CPlantSheet *>(es);
const CSeasonFXSheet &sfs = fs->getFXSheet(CurrSeason);
// if orientation is ok for that kind of plant
float cosMax = cosf(NLMISC::degToRad(sfs.AngleMin));
float cosMin = cosf(NLMISC::degToRad(sfs.AngleMax));
if (cosMax < cosMin) std::swap(cosMin, cosMax);
if (infos.Normal.z < cosMin) continue; // not valid
if (infos.Normal.z > cosMax) continue; // not valid
CTimedFX newFX;
#if !FINAL_VERSION
// for debug display, tells that it was generated dynamically
newFX.FromIG = false;
#endif
// spawn a primitive on the quad
float weight[3];
// compute weight values by computing some noise values around
weight[0] = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.415f * NLMISC::CVector::I);
weight[1] = computeUniformNoise(_Noise, infos.Center - (float) (currPrimIndex + 1) * _CellSize * 1.568f * NLMISC::CVector::I);
weight[2] = computeUniformNoise(_Noise, infos.Center - (float) (currPrimIndex + 1) * _CellSize * 1.512f * NLMISC::CVector::J);
bool tri = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.898f * NLMISC::CVector::I) > 0.5f; // choose a tri to use
// if by extraordinary...
if (weight[0] == 0.f && weight[1] == 0.f && weight[2] == 0.f)
{
weight[0] = 1.f;
}
// normalize weights
float invTotalWeight = 1.f / (weight[0] + weight[1] + weight[2]);
// choose one of the tri to spawn fx (the 2 tri of the quad are not planar)
if (tri)
{
newFX.SpawnPosition = invTotalWeight * (weight[0] * infos.Corners[0] + weight[1] * infos.Corners[1] + weight[2] * infos.Corners[2]);
}
else
{
newFX.SpawnPosition = invTotalWeight * (weight[0] * infos.Corners[1] + weight[1] * infos.Corners[2] + weight[2] * infos.Corners[3]);
}
// see if the fx must be aligned on water
if (sfs.AlignOnWater)
{
float height;
bool splashEnabled;
bool hasWater = ContinentMngr.cur()->WaterMap.getWaterHeight(NLMISC::CVector2f(newFX.SpawnPosition.x, newFX.SpawnPosition.y), height, splashEnabled);
if (hasWater)
{
newFX.SpawnPosition.z = height;
}
}
newFX.SpawnPosition.z += sfs.ZOffset;
// fit K axis of model with the normal, by doing a rotation around K ^ Normal by an angle alpha
// whose cos(alpha) is K * Normal = Normal.Z
// K ^ Normal resolves to [-y x 0]
// if z is near from 1.f or -1.f then no rotation is performed (because [-y x 0] tends to 0 and can't be normalized)
CVector rotAxis; // rotation axis to match Z of model with normal
float angle; // angle of rotation to match Z of model with normal
// see if want rotation
if (!sfs.DontRotate)
{
if (1.f - infos.Normal.z < 10e-4)
{
rotAxis = NLMISC::CVector::I; // any axis in the (x, y) plane will be ok
angle = 0.f;
}
else if (infos.Normal.z + 1.f < 10e-4)
{
rotAxis = NLMISC::CVector::I; // any axis in the (x, y) plane will be ok
angle = (float) NLMISC::Pi;
}
else
{
rotAxis.set(- infos.Normal.y, infos.Normal.x, 0.f);
angle = acosf(infos.Normal.z);
}
}
float angleAroundNormal;
// see if want rotation around normal
if (!sfs.DontRotateAroundLocalZ)
{
// Once instance is positionned, rotate it around its normal for more variety
angleAroundNormal = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.1213f * NLMISC::CVector::K);
}
// build final rot
if (!sfs.DontRotate && !sfs.DontRotateAroundLocalZ)
{
newFX.Rot = NLMISC::CQuat(infos.Normal, angleAroundNormal) * NLMISC::CQuat(rotAxis, angle);
}
else if (!sfs.DontRotate)
{
newFX.Rot = NLMISC::CQuat(rotAxis, angle);
}
else if (!sfs.DontRotateAroundLocalZ)
{
newFX.Rot = NLMISC::CQuat(NLMISC::CVector::K, angleAroundNormal);
}
else
{
// no rotation at all
newFX.Rot = NLMISC::CQuat::Identity;
}
// deal with scale
if (!sfs.WantScaling)
{
newFX.Scale.set(1.f, 1.f, 1.f);
}
else
{
if (sfs.UniformScale)
{
float scaleBlend = computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 3.2371f * NLMISC::CVector::J);
newFX.Scale = scaleBlend * sfs.ScaleMax + (1.f - scaleBlend) * sfs.ScaleMin;
}
else
{
// compute a different blend factor for each axis
CVector scaleBlend(computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 3.2371f * NLMISC::CVector::J),
computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 2.9784f * NLMISC::CVector::J),
computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 1.1782f * NLMISC::CVector::J));
newFX.Scale.set(scaleBlend.x * sfs.ScaleMax.x + (1.f - scaleBlend.x) * sfs.ScaleMin.x,
scaleBlend.y * sfs.ScaleMax.y + (1.f - scaleBlend.y) * sfs.ScaleMin.y,
scaleBlend.z * sfs.ScaleMax.z + (1.f - scaleBlend.z) * sfs.ScaleMin.z);
}
}
newFX.FXSheet = &sfs;
fxToSpawn.push_back(newFX);
}
}
while (k != iv.V.size());
if (!fxToSpawn.empty())
{
CTimedFXManager::TFXGroupHandle fxsHandle = CTimedFXManager::getInstance(). add(fxToSpawn, CurrSeason);
#ifdef NL_DEBUG
// make sure that tile is not inserted twice
TTileIDToFX::iterator testIt = _ActiveFXs.find(infos.TileID);
nlassert(testIt == _ActiveFXs.end());
#endif
_ActiveFXs[infos.TileID] = fxsHandle;
#ifdef NL_DEBUG
_ActiveTilesWithFX[infos.TileID] = infos;
#endif
}
}
// ********************************************************************************************
void CMicroLifeManager::tileRemoved(uint64 id)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
#ifdef NL_DEBUG
CHashMap<uint64, NL3D::CTileAddedInfo>::iterator tileIt = _ActiveTiles.find(id);
if (tileIt != _ActiveTiles.end())
{
_ActiveTiles.erase(tileIt);
}
tileIt = _ActiveTilesWithFX.find(id);
if (tileIt != _ActiveTilesWithFX.end())
{
_ActiveTilesWithFX.erase(tileIt);
}
#endif
TTileIDToFX::iterator it = _ActiveFXs.find(id);
if (it == _ActiveFXs.end()) return;
// remove FX from the manager
CTimedFXManager::getInstance().shutDown(it->second);
_ActiveFXs.erase(it);
}
static const NLMISC::CRGBA DebugCols[] =
{
NLMISC::CRGBA(255, 32, 32),
NLMISC::CRGBA(32, 255, 32),
NLMISC::CRGBA(255, 255, 32),
NLMISC::CRGBA(32, 255, 255),
NLMISC::CRGBA(255, 32, 255),
NLMISC::CRGBA(255, 127, 32),
NLMISC::CRGBA(255, 255, 255)
};
static const uint NumDebugCols = sizeof(DebugCols) / sizeof(DebugCols[0]);
// ********************************************************************************************
void CMicroLifeManager::dumpMLGrid(const std::string &filename)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (_Grid.empty())
{
nlwarning("Grid not built");
return;
}
NLMISC::CBitmap bm;
bm.resize(_GridWidth, _GridHeight, NLMISC::CBitmap::RGBA);
NLMISC::CRGBA *pix = (NLMISC::CRGBA *) bm.getPixels(0).getPtr();
for(uint x = 0; x < _GridWidth; ++x)
{
for(uint y = 0; y < _GridHeight; ++y)
{
if (_Grid[x + y *_GridWidth] == 0)
{
pix[x + y * _GridWidth] = CRGBA(127, 127, 127);
}
else
{
pix[x + y * _GridWidth] = DebugCols[_Grid[x + y *_GridWidth] % NumDebugCols];
}
}
}
NLMISC::COFile f;
if (!f.open(filename))
{
nlwarning("Can't open %s for writing", filename.c_str());
return;
}
bm.writeTGA(f, 24, true);
f.close();
}
// ********************************************************************************************
void CMicroLifeManager::renderMLZones(const NLMISC::CVector2f &camPos, float maxDist /*=1000.f*/)
{
FPU_CHECKER
H_AUTO_USE(RZ_MicroLifeManager)
if (_Grid.empty()) return;
// no fast at all version
Driver->setViewMatrix(Scene->getCam().getMatrix().inverted());
NL3D::CFrustum fr;
Scene->getCam().getFrustum(fr.Left, fr.Right, fr.Bottom, fr.Top, fr.Near, fr.Far);
fr.Perspective = true;
Driver->setFrustum(fr);
Driver->setModelMatrix(NLMISC::CMatrix::Identity);
float userZ = UserEntity ? (float) UserEntity->pos().z : 0.f;
for(uint k = 0; k < _PossibleOverlapPolyLists.size(); ++k)
{
const CGridOverlapPolyInfoVector &currPolyList = _PossibleOverlapPolyLists[k];
for(uint l = 0; l < currPolyList.V.size(); ++l)
{
const std::vector<NLMISC::CVector2f> &verts = currPolyList.V[l].Poly.Vertices;
NLMISC::CLineColor line;
line.Color0 = DebugCols[currPolyList.V[l].PrimitiveIndex % NumDebugCols];
line.Color0.add(line.Color0, NLMISC::CRGBA(127, 127, 127));
line.Color1 = line.Color0;
for(uint m = 0; m < verts.size(); ++m)
{
line.V0.set(verts[m].x, verts[m].y, userZ);
line.V1.set(verts[(m + 1) % verts.size()].x, verts[(m + 1) % verts.size()].y, userZ);
Driver->drawLine(line, GenericMat);
line.V0.z = userZ + 5.f;
line.V1.z = userZ + 5.f;
Driver->drawLine(line, GenericMat);
line.V0.set(verts[m].x, verts[m].y, userZ);
line.V1.set(verts[m].x, verts[m].y, userZ + 5.f);
Driver->drawLine(line, GenericMat);
}
}
}
for (uint x = 0; x < _GridWidth; ++x)
{
for (uint y = 0; y < _GridHeight; ++y)
{
const CGridOverlapPolyInfoVector &currPolyList = _PossibleOverlapPolyLists[_Grid[x + _GridWidth * y]];
if (currPolyList.V.empty()) continue;
// see if cell not too far
NLMISC::CVector2f pos(x * _CellSize + _MinCorner.x, y * _CellSize + _MinCorner.y);
if ((camPos - pos).norm() > maxDist) continue; // too far, don't display
// display box for each primitive type
NLMISC::CVector cornerMin(pos.x, pos.y, userZ - 5.f);
NLMISC::CVector cornerMax(pos.x + _CellSize, pos.y + _CellSize, userZ + 5.f);
for(uint l = 0; l < currPolyList.V.size(); ++l)
{
// add a bias each time to see when several primitives are overlapped
NLMISC::CVector bias = (float) currPolyList.V[l].PrimitiveIndex * NLMISC::CVector(0.01f, 0.f, 0.1f);
CRGBA col = DebugCols[currPolyList.V[l].PrimitiveIndex % NumDebugCols];
if (!currPolyList.V[l].IsFullyCovered)
{
drawBox(cornerMin + bias, cornerMax + bias, col);
}
else
{
col.R /= 2;
col.G /= 2;
col.B /= 2;
drawBox(cornerMin + bias, cornerMax + bias, col);
}
}
}
}
}
#ifdef NL_DEBUG
// ********************************************************************************************
void CMicroLifeManager::renderActiveTiles()
{
FPU_CHECKER
/*
Driver->setViewMatrix(Scene->getCam().getMatrix().inverted());
NL3D::CFrustum fr;
Scene->getCam().getFrustum(fr.Left, fr.Right, fr.Bottom, fr.Top, fr.Near, fr.Far);
fr.Perspective = true;
Driver->setFrustum(fr);
Driver->setModelMatrix(NLMISC::CMatrix::Identity);
NL3D::UDriver::TPolygonMode oldPolyMode = Driver->getPolygonMode();
Driver->setPolygonMode(NL3D::UDriver::Line);
NL3D::UMaterial mat = Driver->createMaterial();
mat->initUnlit();
mat->setDoubleSided(true);
mat->setColor(CRGBA::Green);
for(std::hash_map<uint64, NL3D::CTileAddedInfo>::iterator it = _ActiveTiles.begin(); it != _ActiveTiles.end(); ++it)
{
Driver->drawLine(NLMISC::CLine(it->second.Corners[0], it->second.Corners[1]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[1], it->second.Corners[2]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[2], it->second.Corners[3]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[3], it->second.Corners[0]), *mat);
}
mat->setColor(CRGBA::Red);
for(std::hash_map<uint64, NL3D::CTileAddedInfo>::iterator it = _ActiveTilesWithFX.begin(); it != _ActiveTilesWithFX.end(); ++it)
{
Driver->drawLine(NLMISC::CLine(it->second.Corners[0], it->second.Corners[1]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[1], it->second.Corners[2]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[2], it->second.Corners[3]), *mat);
Driver->drawLine(NLMISC::CLine(it->second.Corners[3], it->second.Corners[0]), *mat);
}
Driver->deleteMaterial(mat);
Driver->setPolygonMode(oldPolyMode);
*/
}
#endif
////////////////////
// DEBUG COMMANDS //
////////////////////
#ifdef NL_DEBUG
// display micro-life active tiles
NLMISC_COMMAND(showMLActiveTiles,"display micro-life active tiles", "<0 = off, 1 = on>")
{
if (args.size() != 1) return false;
fromString(args[0], DisplayMicroLifeActiveTiles);
return true;
}
#endif
#if !FINAL_VERSION
#include "continent_manager.h"
// ******************************************************************************************************************
// display micro-life zone on screen
NLMISC_COMMAND(showMLZones,"display micro-life zones", "<0 = off, 1 = on>")
{
if (args.size() != 1) return false;
fromString(args[0], DisplayMicroLifeZones);
return true;
}
// ******************************************************************************************************************
// dump micro-life zone in a tga file
NLMISC_COMMAND(dumpMLZones,"display micro-life zones", "<filename>")
{
if (args.size() != 1) return false;
CMicroLifeManager::getInstance().dumpMLGrid(args[0]);
return true;
}
// ******************************************************************************************************************
// reload micro-life zones
NLMISC_COMMAND(reloadMLZones, "reload micro-life zones", "")
{
if (!args.empty()) return false;
ClientSheetsStrings.memoryUncompress();
// reload .flora
std::vector<std::string> exts;
exts.push_back("flora");
NLMISC::IProgressCallback progress;
SheetMngr.loadAllSheet(progress, true, false, true, true, &exts);
// reload .plant 5but keep at their current adress)
CSheetManager sheetManager;
exts[0] = "plant";
sheetManager.loadAllSheet(progress, true, false, false, true, &exts);
//
const CSheetManager::TEntitySheetMap &sm = SheetMngr.getSheets();
for(CSheetManager::TEntitySheetMap::const_iterator it = sm.begin(); it != sm.end(); ++it)
{
if (it->second.EntitySheet && it->second.EntitySheet->Type == CEntitySheet::PLANT)
{
// find matching sheet in new sheetManager
const CEntitySheet *other = sheetManager.get(it->first);
if (other)
{
// replace data in place
*(CPlantSheet *) it->second.EntitySheet = *(const CPlantSheet *) other;
}
}
}
//
ClientSheetsStrings.memoryCompress();
// reload prims
ContinentMngr.cur()->loadMicroLife();
if (Landscape) Landscape->invalidateAllTiles();
return true;
}
#endif
Reference in a new issue Copy permalink