mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-05 01:34:50 +00:00
241 lines
No EOL
6.9 KiB
C++
241 lines
No EOL
6.9 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifndef CL_SCRRENSHOT_ISLANDS_H
|
|
#define CL_SCRRENSHOT_ISLANDS_H
|
|
|
|
// Misc
|
|
#include "nel/misc/singleton.h"
|
|
#include "nel/misc/vector_2f.h"
|
|
#include "nel/misc/rgba.h"
|
|
#include "nel/misc/bitmap.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
namespace NL3D
|
|
{
|
|
class UScene;
|
|
class ULandscape;
|
|
}
|
|
|
|
namespace R2
|
|
{
|
|
class CProximityZone;
|
|
|
|
typedef uint16 TBufferEntry;
|
|
typedef std::vector<TBufferEntry> TBuffer;
|
|
typedef std::vector<uint32> TOffsetsVector;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// class CScreenshotIslands
|
|
//-----------------------------------------------------------------------------
|
|
struct CIslandData
|
|
{
|
|
NLMISC::CVector2f EntryPoint;
|
|
NLMISC::CVector2f Max;
|
|
NLMISC::CVector2f Min;
|
|
|
|
CIslandData()
|
|
{
|
|
EntryPoint = NLMISC::CVector2f(0, 0);
|
|
Max = NLMISC::CVector2f(0, 0);
|
|
Min = NLMISC::CVector2f(0, 0);
|
|
}
|
|
|
|
CIslandData(float x, float y)
|
|
{
|
|
EntryPoint = NLMISC::CVector2f(x, y);
|
|
Max = NLMISC::CVector2f(0, 0);
|
|
Min = NLMISC::CVector2f(0, 0);
|
|
}
|
|
};
|
|
|
|
struct CContinentData
|
|
{
|
|
std::string SmallBank;
|
|
std::string FarBank;
|
|
std::string IGFile;
|
|
std::string CoarseMeshMap;
|
|
NLMISC::CVector2f ZoneMin;
|
|
NLMISC::CVector2f ZoneMax;
|
|
std::list< std::string > Islands;
|
|
NLMISC::CRGBA Ambiant;
|
|
NLMISC::CRGBA Diffuse;
|
|
|
|
CContinentData() {}
|
|
};
|
|
|
|
typedef std::map< const std::string, CProximityZone> TIslandsData;
|
|
typedef std::map< NLMISC::CVector2f, bool > TIslandsMap;
|
|
typedef std::map< const std::string, CContinentData > TContinentsData;
|
|
typedef std::map< std::string, std::list< NLMISC::CVector2f > > TIslandsBordersMap;
|
|
|
|
class CScreenshotIslands : public NLMISC::CSingleton<CScreenshotIslands>
|
|
{
|
|
|
|
public:
|
|
|
|
CScreenshotIslands();
|
|
|
|
void buildScreenshots();
|
|
|
|
private:
|
|
|
|
void init();
|
|
|
|
void loadIslands();
|
|
|
|
void buildIslandsTextures();
|
|
|
|
void getBuffer(NL3D::UScene * scene, NL3D::ULandscape * landscape, NLMISC::CBitmap &btm);
|
|
|
|
bool getPosFromZoneName(const std::string &name, NLMISC::CVector2f &dest);
|
|
|
|
void writeProximityBufferToTgaFile(const std::string& fileName,const TBuffer& buffer,
|
|
uint32 scanWidth,uint32 scanHeight);
|
|
|
|
void processProximityBuffer(TBuffer& inputBuffer, uint32 lineLength, TBuffer& resultBuffer);
|
|
|
|
void buildBackTextureHLS(const std::string & islandName, const NLMISC::CBitmap & islandBitmap);
|
|
|
|
void searchIslandsBorders();
|
|
|
|
void attenuateIslandBorders(const std::string & islandName, NLMISC::CBitmap & islandBitmap, const CProximityZone & islandData);
|
|
|
|
TIslandsData _IslandsData;
|
|
TIslandsMap _IslandsMap;
|
|
TContinentsData _ContinentsData;
|
|
std::list< std::string > _SeasonSuffixes;
|
|
int _MeterPixelSize;
|
|
std::string _OutDirectory;
|
|
std::list< std::string > _TempFileNames;
|
|
TIslandsBordersMap _BorderIslands;
|
|
bool _Vegetation;
|
|
bool _InverseZTest;
|
|
|
|
NLMISC::CRGBA _BackColor;
|
|
NLMISC::CBitmap _BackBitmap;
|
|
std::string _CompleteIslandsFile;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class CProximityZone
|
|
{
|
|
public:
|
|
typedef std::vector<uint32> TOffsets;
|
|
|
|
// ctor
|
|
// scanWidth and scanHeight define the dimentions of the buffer that this zone is being extracted from
|
|
// xOffset and yOffset are for re-mapping coordinates from buffer-relative to absolute ryzom world coordinates
|
|
CProximityZone(uint32 scanWidth=0,uint32 scanHeight=0,sint32 xOffset=0, sint32 yOffset=0);
|
|
|
|
// add an 'accessible position' to a zone (offset is y*scanWidth+x)
|
|
bool add(uint32 offset);
|
|
|
|
// zone dimention accessors (note that zone dimentions line up with 160x160 world zones)
|
|
// note that this means that the zone bounds may extend outside the scan area
|
|
uint32 getZoneWidth() const;
|
|
uint32 getZoneHeight() const;
|
|
sint32 getZoneXMin() const;
|
|
sint32 getZoneYMin() const;
|
|
uint32 getZoneXMax() const;
|
|
uint32 getZoneYMax() const;
|
|
|
|
// read accessors for the bounding limits that define the area occupied by the accessible points
|
|
uint32 getBoundXMin() const;
|
|
uint32 getBoundYMin() const;
|
|
uint32 getBoundXMax() const;
|
|
uint32 getBoundYMax() const;
|
|
|
|
// read accessor for the _Offsets vector
|
|
// this is a vector of offsets into the scan area. It needs to be remapped to zone offsets
|
|
// via the remapOffset() routine in order to be used to index into a zone buffer
|
|
const TOffsets& getOffsets() const;
|
|
|
|
// remap a scan buffer offset to a zone offset by decomposing into x and y parts and
|
|
// subtracting getZoneXMin() and getZoneYMin()
|
|
uint32 remapOffset(uint32 bufferOffset) const;
|
|
|
|
private:
|
|
// parameters setup at construction time, giving info on the context that we're in
|
|
uint32 _ScanWidth;
|
|
uint32 _ScanHeight;
|
|
sint32 _XOffset;
|
|
sint32 _YOffset;
|
|
uint32 _MaxOffset;
|
|
|
|
// the vector of points that are part of this zone
|
|
TOffsets _Offsets;
|
|
|
|
// the min and max coords of the points that are part of this zone
|
|
uint32 _XMax;
|
|
uint32 _XMin;
|
|
uint32 _YMax;
|
|
uint32 _YMin;
|
|
|
|
// border add to bouding zone (pixels number)
|
|
int _BorderPixels;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// class CProximityMapBuffer
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
class CProximityMapBuffer
|
|
{
|
|
public:
|
|
typedef std::vector<CProximityZone> TZones;
|
|
|
|
// load a cwmap2 file and setup this object from its contents
|
|
// the 'name' parameter is the full file name of the file to load with path and extension
|
|
void load(const std::string& name);
|
|
|
|
// scan the buffer to generate the set of non-connecting zones that it contains
|
|
void calculateZones(TZones& zones);
|
|
|
|
// generate the proximity map for a given zone
|
|
void generateZoneProximityMap(const CProximityZone& zone,TBuffer& zoneBuffer);
|
|
|
|
// read accessors...
|
|
const TBuffer& getBuffer() const;
|
|
uint32 getScanHeight() const;
|
|
uint32 getScanWidth() const;
|
|
|
|
// buffer coordinate to world coordinate offsets...
|
|
sint32 _XOffset;
|
|
sint32 _YOffset;
|
|
|
|
private:
|
|
// private routine used by generateZoneProximityMap() to setup the zoneBuffer with the accessible points set
|
|
void _prepareBufferForZoneProximityMap(const CProximityZone& zone,TBuffer& zoneBuffer,TOffsetsVector& accessiblePoints);
|
|
|
|
private:
|
|
// the width and heilght of the scan zone (ie the dimentions of the buffer)
|
|
uint32 _ScanWidth;
|
|
uint32 _ScanHeight;
|
|
|
|
// vector representing 2d array of points [_ScanHeight][_ScanWidth]
|
|
TBuffer _Buffer;
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#endif |