Serious-Engine/Sources/Engine/Terrain/Terrain.cpp

2161 lines
66 KiB
C++
Raw Normal View History

2016-03-12 01:20:51 +01:00
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
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 General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
2016-03-11 14:57:17 +01:00
#include "Engine/StdH.h"
2016-03-11 14:57:17 +01:00
#include <Engine/Base/Stream.h>
#include <Engine/Base/ListIterator.inl>
#include <Engine/Math/Projection.h>
#include <Engine/Math/FixInt.h>
#include <Engine/Graphics/DrawPort.h>
2016-03-11 14:57:17 +01:00
#include <Engine/Graphics/ImageInfo.h>
#include <Engine/Graphics/GfxLibrary.h>
#include <Engine/Terrain/Terrain.h>
#include <Engine/Terrain/TerrainRender.h>
#include <Engine/Terrain/TerrainEditing.h>
#include <Engine/Terrain/TerrainMisc.h>
#include <Engine/Templates/Stock_CTextureData.h>
#include <Engine/Entities/Entity.h>
#include <Engine/Entities/ShadingInfo.h>
#include <Engine/Graphics/Font.h>
#include <Engine/Base/Console.h>
#include <Engine/Rendering/Render.h>
extern CTerrain *_ptrTerrain;
extern BOOL _bWorldEditorApp; // is this world edtior app
static INDEX _iTerrainVersion = 9; // Current terrain version
static INDEX ctGeneratedTopMaps = 0; // TEMP
static INDEX ctGlobalTopMaps = 0; // TEMP
INDEX _ctShadowMapUpdates = 0; // TEMP
// TEMP
INDEX _ctNodesVis = 0;
INDEX _ctTris = 0;
INDEX _ctDelayedNodes = 0;
static void ShowTerrainInfo(CAnyProjection3D &apr, CDrawPort *pdp, CTerrain *ptrTerrain); // TEMP
/*
* Terrain initialization
*/
CTerrain::CTerrain()
{
tr_vStretch = FLOAT3D(1,0.05f,1);
tr_fDistFactor = 32;
tr_iMaxTileLod = 0;
tr_iSelectedLayer = 0;
tr_ctDriverChanges = -1;
tr_pixHeightMapWidth = 256;
tr_pixHeightMapHeight = 256;
tr_pixTopMapWidth = 256;
tr_pixTopMapHeight = 256;
tr_pixFirstMipTopMapWidth = 256;
tr_pixFirstMipTopMapHeight = 256;
tr_ptdDetailMap = NULL;
tr_auwHeightMap = NULL;
tr_aubEdgeMap = NULL;
tr_auwShadingMap = NULL;
// TEMP
try {
tr_ptdDetailMap = _pTextureStock->Obtain_t((CTString)"Textures\\Detail\\Crumples04.tex");
} catch(char *) {
}
// Set size of shadow and shading maps
SetShadowMapsSize(0,0);
// Set terrain size
SetTerrainSize(FLOAT3D(256,80,256));
// Set num of quads in one tile
SetQuadsPerTileRow(32);
SetFlags(TR_REGENERATE);
}
// Render visible terrain tiles
void CTerrain::Render(CAnyProjection3D &apr, CDrawPort *pdp)
{
// prepare gfx stuff
PrepareScene(apr, pdp, this);
if(tr_ctDriverChanges!=_pGfx->gl_ctDriverChanges) {
tr_ctDriverChanges = _pGfx->gl_ctDriverChanges;
// RefreshTerrain();
}
// if terrain is not frozen
extern INDEX ter_bNoRegeneration;
if(GetFlags()&TR_REGENERATE && !ter_bNoRegeneration) {
// Regenerate tiles
ReGenerate();
}
// if shadow map must be regenerated
if(GetFlags()&TR_UPDATE_SHADOWMAP) {
UpdateShadowMap();
}
// if top map regen is allowed
if(GetFlags()&TR_ALLOW_TOP_MAP_REGEN) {
// if top map regen is requested
if(GetFlags()&TR_REGENERATE_TOP_MAP) {
// update terrain top map
UpdateTopMap(-1);
// remove request for top map regen
RemoveFlag(TR_REGENERATE_TOP_MAP);
}
// remove flag that allows terrain to regenerate top map
RemoveFlag(TR_ALLOW_TOP_MAP_REGEN);
}
// show
RenderTerrain();
// if flag show brush selection has been set
if(GetFlags()&TR_SHOW_SELECTION) {
ShowSelectionInternal(this);
// remove show selection terrain flag
RemoveFlag(TR_SHOW_SELECTION);
}
// if flag for quadtree rebuilding is set
if(GetFlags()&TR_REBUILD_QUADTREE) {
// Resize quadtree
UpdateQuadTree();
// remove flag for quadtree rebuilding
RemoveFlag(TR_REBUILD_QUADTREE);
}
RemoveFlag(TR_HAS_FOG);
RemoveFlag(TR_HAS_HAZE);
extern INDEX ter_bShowWireframe;
// if wireframe mode forced
if(ter_bShowWireframe) {
COLOR colWire = 0xFFFFFFFF;
RenderTerrainWire(colWire);
}
extern INDEX ter_bShowQuadTree;
// if showing of quad tree is required
if(ter_bShowQuadTree) {
DrawQuadTree();
}
extern INDEX ter_bShowInfo;
if(ter_bShowInfo) {
ShowTerrainInfo(apr, pdp, this);
}
_ptrTerrain = NULL;
}
void CTerrain::RenderWireFrame(CAnyProjection3D &apr, CDrawPort *pdp, COLOR &colEdges)
{
// prepare gfx stuff
PrepareScene(apr, pdp, this);
// Regenerate tiles
if(tr_ctTiles>=0) {
CTerrainTile &tt = tr_attTiles[0];
if(tt.tt_iLod == -1) {
ReGenerate();
}
}
// show
RenderTerrainWire(colEdges);
}
// Create empty terrain with given size
void CTerrain::CreateEmptyTerrain_t(PIX pixWidth,PIX pixHeight)
{
_ptrTerrain = this;
// Clear old terrain data if exists
Clear();
ASSERT(tr_auwHeightMap==NULL);
ASSERT(tr_aubEdgeMap==NULL);
AllocateHeightMap(pixWidth,pixHeight);
AddDefaultLayer_t();
// Rebuild terrain
ReBuildTerrain();
_ptrTerrain = NULL;
}
// Import height map from targa file
void CTerrain::ImportHeightMap_t(CTFileName fnHeightMap, BOOL bUse16b/*=TRUE*/)
{
_ptrTerrain = this;
BOOL bResizeTerrain = FALSE;
// Load targa file
CImageInfo iiHeightMap;
iiHeightMap.LoadAnyGfxFormat_t(fnHeightMap);
// if new width and height are same
if(tr_pixHeightMapWidth==iiHeightMap.ii_Width && tr_pixHeightMapHeight==iiHeightMap.ii_Height) {
// Clear terrain data without removing layers
bResizeTerrain = FALSE;
} else {
// Clear all terrain data
bResizeTerrain = TRUE;
}
bResizeTerrain = TRUE;
FLOAT fLogWidht = Log2(iiHeightMap.ii_Width-1);
FLOAT fLogHeight = Log2(iiHeightMap.ii_Height-1);
if(fLogWidht!=INDEX(fLogWidht) || fLogHeight!=INDEX(fLogHeight)) {
ThrowF_t("Invalid terrain width or height");
}
if(iiHeightMap.ii_Width!= iiHeightMap.ii_Height) {
ThrowF_t("Only terrains with same width and height are supported in this version");
}
// Reallocate memory for terrain with size
ReAllocateHeightMap(iiHeightMap.ii_Width, iiHeightMap.ii_Height);
INDEX iHeightMapSize = iiHeightMap.ii_Width * iiHeightMap.ii_Height;
UBYTE *puwSrc = &iiHeightMap.ii_Picture[0];
UWORD *puwDst = &tr_auwHeightMap[0];
INDEX iBpp = iiHeightMap.ii_BitsPerPixel/8;
// for each word in loaded image
for(INDEX iw=0;iw<iHeightMapSize;iw++) {
// use 16 bits for importing
if(bUse16b) {
*puwDst = *(UWORD*)puwSrc;
// use 8 bits for importing
} else {
*puwDst = *(UBYTE*)puwSrc<<8;
}
puwDst++;
puwSrc+=iBpp;
}
// Rebuild terrain
ReBuildTerrain();
_ptrTerrain = NULL;
}
// Export height map to targa file
void CTerrain::ExportHeightMap_t(CTFileName fnHeightMap, BOOL bUse16b/*=TRUE*/)
{
ASSERT(tr_auwHeightMap!=NULL);
INDEX iSize = tr_pixHeightMapWidth*tr_pixHeightMapHeight;
CImageInfo iiHeightMap;
iiHeightMap.ii_Width = tr_pixHeightMapWidth;
iiHeightMap.ii_Height = tr_pixHeightMapHeight;
iiHeightMap.ii_BitsPerPixel = 32;
iiHeightMap.ii_Picture = (UBYTE*)AllocMemory(iSize*iiHeightMap.ii_BitsPerPixel/8);
GFXColor *pacolImage = (GFXColor*)&iiHeightMap.ii_Picture[0];
UWORD *puwHeight = tr_auwHeightMap;
for(INDEX ipix=0;ipix<iSize;ipix++) {
*pacolImage = 0x00000000;
if(bUse16b) {
UWORD *puwData = (UWORD*)&pacolImage[0];
*puwData = *puwHeight;
} else {
UBYTE *pubData = (UBYTE*)&pacolImage[0];
UWORD *puwHData = puwHeight;
*pubData = (UBYTE)(*puwHData>>8);
}
pacolImage++;
puwHeight++;
}
iiHeightMap.SaveTGA_t(fnHeightMap);
iiHeightMap.Clear();
}
// Rebuild all terrain
void CTerrain::ReBuildTerrain(BOOL bDelayTileRegen/*=FALSE*/)
{
_ptrTerrain = this;
ClearTopMaps();
ClearTiles();
ClearArrays();
ClearQuadTree();
// Make sure terrain is same size (in metars)
SetTerrainSize(tr_vTerrainSize);
// Build terrain data
BuildTerrainData();
// Build terrain quadtree
BuildQuadTree();
// Generate global top map
GenerateTerrainTopMap();
// Clear current regen list
ClearRegenList();
// Add all tiles to reqen queue
AddAllTilesToRegenQueue();
// if not delaying tile regen
if(!bDelayTileRegen) {
// Regenerate tiles now
ReGenerate();
// Update shadow map
UpdateShadowMap();
}
}
// Refresh terrain
void CTerrain::RefreshTerrain(void)
{
ReBuildTerrain();
}
// Set terrain size
void CTerrain::SetTerrainSize(FLOAT3D vSize)
{
tr_vStretch(1) = vSize(1) / (tr_pixHeightMapWidth-1);
tr_vStretch(2) = vSize(2) / 65535.0f;
tr_vStretch(3) = vSize(3) / (tr_pixHeightMapHeight-1);
// remember new size
tr_vTerrainSize = vSize;
}
template <class Type>
static void CropMap(INDEX iNewWidth, INDEX iNewHeight, INDEX iOldWidth, INDEX iOldHeight, Type *pNewData, Type *pOldData)
{
INDEX iWidth = Min(iOldWidth,iNewWidth);
INDEX iHeight = Min(iOldHeight,iNewHeight);
INDEX iNewStepX = ClampDn(iNewWidth-iOldWidth,0L);
INDEX iOldStepX = ClampDn(iOldWidth-iNewWidth,0L);
INDEX iNew = 0;
INDEX iOld = 0;
for(INDEX iy=0;iy<iHeight;iy++) {
for(INDEX ix=0;ix<iWidth;ix++) {
pNewData[iNew] = pOldData[iOld];
iNew++;
iOld++;
}
iNew += iNewStepX;
iOld += iOldStepX;
}
}
template <class Type>
static void StretchMap(INDEX iNewWidth, INDEX iNewHeight, INDEX iOldWidth, INDEX iOldHeight, Type *pNewData, Type *pOldData)
{
int a=0;
CropMap(iNewWidth,iNewHeight,iOldWidth,iOldHeight,pNewData,pOldData);
}
template <class Type>
static void ShrinkMap(INDEX iNewWidth, INDEX iNewHeight, INDEX iOldWidth, INDEX iOldHeight, Type *pNewData, Type *pOldData)
{
FLOAT fWidth = iNewWidth;
FLOAT fHeight = iNewHeight;
FLOAT fDiffX = (FLOAT)iNewWidth / iOldWidth;
FLOAT fDiffY = (FLOAT)iNewHeight / iOldHeight;
ULONG *pulNewData = (ULONG*)AllocMemory(iNewWidth * iNewHeight * sizeof(ULONG));
memset(pulNewData,0,iNewWidth * iNewHeight * sizeof(ULONG));
INDEX iOldPix = 0;
for(FLOAT fy=0;fy<iNewHeight;fy+=fDiffY) {
for(FLOAT fx=0;fx<iNewWidth;fx+=fDiffX) {
INDEX iNewPix = floor(fx) + floor(fy) * iNewWidth;
pulNewData[iNewPix] += pOldData[iOldPix];
iOldPix++;
}
}
ULONG ulDiv = ceil(1.0f/fDiffX) * ceil(1.0f/fDiffY);
for(INDEX ii=0;ii<iNewWidth*iNewHeight;ii++) {
pNewData[ii] = pulNewData[ii] / ulDiv;
}
FreeMemory(pulNewData);
ASSERT(_CrtCheckMemory());
}
template <class Type>
static void ResizeMap(INDEX iNewWidth, INDEX iNewHeight, INDEX iOldWidth, INDEX iOldHeight, Type *pNewData, Type *pOldData)
{
CropMap(iNewWidth,iNewHeight,iOldWidth,iOldHeight,pNewData,pOldData);
/*
if(iNewWidth>=iOldWidth && iNewHeight>=iOldHeight) {
StretchMap(iNewWidth,iNewHeight,iOldWidth,iOldHeight,pNewData,pOldData);
} else if(iNewWidth<=iOldWidth && iNewHeight<=iOldHeight) {
ShrinkMap(iNewWidth,iNewHeight,iOldWidth,iOldHeight,pNewData,pOldData);
} else {
INDEX iTempWidth = Max(iNewWidth ,iOldWidth);
INDEX iTempHeight = Max(iNewHeight,iOldHeight);
INDEX iTempSize = iTempWidth*iTempHeight*sizeof(Type);
Type *pTempData = (Type*)AllocMemory(iTempSize);
memset(pTempData,0,iTempSize);
StretchMap(iTempWidth,iTempHeight,iOldWidth,iOldHeight,pTempData,pOldData);
ShrinkMap(iNewWidth,iNewHeight,iTempWidth,iTempHeight,pNewData, pTempData);
FreeMemory(pTempData);
}
*/
}
void CTerrain::AllocateHeightMap(PIX pixWidth, PIX pixHeight)
{
ASSERT(tr_auwHeightMap==NULL);
ASSERT(tr_aubEdgeMap==NULL);
FLOAT fLogWidht = Log2(pixWidth-1);
FLOAT fLogHeight = Log2(pixHeight-1);
if(fLogWidht!=INDEX(fLogWidht) || fLogHeight!=INDEX(fLogHeight)) {
ASSERTALWAYS("Invalid terrain width or height");
return;
}
if(pixWidth != pixHeight) {
ASSERTALWAYS("Only terrains with same width and height are supported in this version");
return;
}
INDEX iSize = pixWidth * pixHeight * sizeof(UBYTE);
// Allocate memory for maps
tr_auwHeightMap = (UWORD*)AllocMemory(iSize*2);
tr_aubEdgeMap = (UBYTE*)AllocMemory(iSize);
memset(tr_auwHeightMap,0,iSize*2);
memset(tr_aubEdgeMap,255,iSize);
tr_pixHeightMapWidth = pixWidth;
tr_pixHeightMapHeight = pixHeight;
// Update shadow map size cos it depends on size of height map
SetShadowMapsSize(tr_iShadowMapSizeAspect,tr_iShadingMapSizeAspect);
}
void CTerrain::ReAllocateHeightMap(PIX pixWidth, PIX pixHeight)
{
ASSERT(tr_auwHeightMap!=NULL);
ASSERT(tr_aubEdgeMap!=NULL);
FLOAT fLogWidht = Log2(pixWidth-1);
FLOAT fLogHeight = Log2(pixHeight-1);
if(fLogWidht!=INDEX(fLogWidht) || fLogHeight!=INDEX(fLogHeight)) {
ASSERTALWAYS("Invalid terrain width or height");
return;
}
if(pixWidth != pixHeight) {
ASSERTALWAYS("Only terrains with same width and height are supported in this version");
return;
}
INDEX iSize = pixWidth * pixHeight * sizeof(UBYTE);
// Allocate memory for maps
UWORD *auwHeightMap = (UWORD*)AllocMemory(iSize*2);
UBYTE *aubEdgeMap = (UBYTE*)AllocMemory(iSize);
// Resize height map
memset(auwHeightMap,0,iSize*2);
ResizeMap(pixWidth,pixHeight,tr_pixHeightMapWidth,tr_pixHeightMapHeight,auwHeightMap,tr_auwHeightMap);
// Resize edge map
memset(aubEdgeMap,255,iSize);
ResizeMap(pixWidth,pixHeight,tr_pixHeightMapWidth,tr_pixHeightMapHeight,aubEdgeMap,tr_aubEdgeMap);
// for each layer
INDEX cttl = tr_atlLayers.Count();
for(INDEX itl=0;itl<cttl;itl++) {
CTerrainLayer &tl = tr_atlLayers[itl];
// Allocate memory for layer mask
UBYTE *aubLayerMask = (UBYTE*)AllocMemory(iSize);
memset(aubLayerMask,0,iSize);
ASSERT(tl.tl_iMaskWidth == tr_pixHeightMapWidth);
ASSERT(tl.tl_iMaskHeight == tr_pixHeightMapHeight);
// resize layer
ResizeMap(pixWidth,pixHeight,tl.tl_iMaskWidth,tl.tl_iMaskHeight,aubLayerMask,tl.tl_aubColors);
// Free old mask
FreeMemory(tl.tl_aubColors);
// Apply changes
tl.tl_aubColors = aubLayerMask;
tl.tl_iMaskWidth = pixWidth;
tl.tl_iMaskHeight = pixHeight;
// if this is first layer
if(itl==0) {
// fill it
tl.ResetLayerMask(255);
}
}
// Free old maps
FreeMemory(tr_auwHeightMap);
FreeMemory(tr_aubEdgeMap);
// Apply changes
tr_auwHeightMap = auwHeightMap;
tr_aubEdgeMap = aubEdgeMap;
tr_pixHeightMapWidth = pixWidth;
tr_pixHeightMapHeight = pixHeight;
ASSERT(_CrtCheckMemory());
2016-03-11 14:57:17 +01:00
// Update shadow map size cos it depends on size of height map
SetShadowMapsSize(tr_iShadowMapSizeAspect,tr_iShadingMapSizeAspect);
/*
// Clear current maps if they exists
ClearHeightMap();
ClearEdgeMap();
ClearLayers();
*/
/*
ASSERT(tr_auwHeightMap==NULL);
ASSERT(tr_aubEdgeMap==NULL);
INDEX iSize = sizeof(UBYTE)*pixWidth*pixHeight;
// Allocate memory for heightmap
tr_auwHeightMap = (UWORD*)AllocMemory(iSize*2);
// Allocate memory for edge map
tr_aubEdgeMap = (UBYTE*)AllocMemory(iSize);
// Reset height map to 0
memset(tr_auwHeightMap,0,iSize*2);
// Reset edge map to 255
memset(tr_aubEdgeMap,255,iSize);
tr_pixHeightMapWidth = pixWidth;
tr_pixHeightMapHeight = pixHeight;
*/
}
// Set shadow map size aspect (relative to height map size) and shading map aspect (relative to shadow map size)
void CTerrain::SetShadowMapsSize(INDEX iShadowMapAspect, INDEX iShadingMapAspect)
{
// TEMP
#pragma message(">> Clamp dn SetShadowMapsSize")
if(iShadingMapAspect<0) {
iShadingMapAspect = 0;
}
ASSERT(iShadingMapAspect>=0);
tr_iShadowMapSizeAspect = iShadowMapAspect;
tr_iShadingMapSizeAspect = iShadingMapAspect;
if(GetShadowMapWidth()<32 || GetShadingMapHeight()<32) {
tr_iShadowMapSizeAspect = -(FastLog2(tr_pixHeightMapWidth-1)-5);
}
2016-03-22 19:03:12 +01:00
if(GetShadingMapWidth()<32 || GetShadingMapHeight()<32) {
2016-03-11 14:57:17 +01:00
tr_iShadingMapSizeAspect = 0;
}
PIX pixShadowMapWidth = GetShadowMapWidth();
PIX pixShadowMapHeight = GetShadowMapHeight();
PIX pixShadingMapWidth = GetShadingMapWidth();
PIX pixShadingMapHeight = GetShadingMapHeight();
// Clear current shadow map
ClearShadowMap();
ULONG ulShadowMapFlags = 0;
// if current app is world editor app
if(_bWorldEditorApp) {
// force texture to be static
ulShadowMapFlags = TEX_STATIC;
}
// Create new shadow map texture
ASSERT(tr_tdShadowMap.td_pulFrames==NULL);
CreateTexture(tr_tdShadowMap,pixShadowMapWidth,pixShadowMapHeight,ulShadowMapFlags);
// Reset shadow map texture
memset(&tr_tdShadowMap.td_pulFrames[0],0,sizeof(COLOR)*pixShadowMapWidth*pixShadowMapHeight);
// Create new shading map
ASSERT(tr_auwShadingMap==NULL);
tr_auwShadingMap = (UWORD*)AllocMemory(pixShadingMapWidth*pixShadingMapHeight*sizeof(UWORD));
// Reset shading map
memset(&tr_auwShadingMap[0],0,pixShadingMapWidth*pixShadingMapHeight*sizeof(UWORD));
}
// Set size of terrain top map texture
void CTerrain::SetGlobalTopMapSize(PIX pixTopMapSize)
{
FLOAT fLogSize = Log2(pixTopMapSize);
if(fLogSize!=INDEX(fLogSize)) {
ASSERTALWAYS("Invalid top map size");
return;
}
tr_pixTopMapWidth = pixTopMapSize;
tr_pixTopMapHeight = pixTopMapSize;
}
// Set size of top map texture for tiles in lower lods
void CTerrain::SetTileTopMapSize(PIX pixLodTopMapSize)
{
FLOAT fLogSize = Log2(pixLodTopMapSize);
if(fLogSize!=INDEX(fLogSize)) {
ASSERTALWAYS("Invalid top map size");
return;
}
tr_pixFirstMipTopMapWidth = pixLodTopMapSize;
tr_pixFirstMipTopMapHeight = pixLodTopMapSize;
}
// Set lod distance factor
void CTerrain::SetLodDistanceFactor(FLOAT fLodDistance)
{
tr_fDistFactor = ClampDn(fLodDistance,0.1f);
}
// Get shadow map size
PIX CTerrain::GetShadowMapWidth(void)
2016-03-11 14:57:17 +01:00
{
if(tr_iShadowMapSizeAspect<0) {
return (tr_pixHeightMapWidth-1)>>-tr_iShadowMapSizeAspect;
} else {
return (tr_pixHeightMapWidth-1)<<tr_iShadowMapSizeAspect;
}
}
PIX CTerrain::GetShadowMapHeight(void)
2016-03-11 14:57:17 +01:00
{
if(tr_iShadowMapSizeAspect<0) {
return (tr_pixHeightMapHeight-1)>>-tr_iShadowMapSizeAspect;
} else {
return (tr_pixHeightMapHeight-1)<<tr_iShadowMapSizeAspect;
}
}
// Get shading map size
PIX CTerrain::GetShadingMapWidth(void)
2016-03-11 14:57:17 +01:00
{
ASSERT(tr_iShadingMapSizeAspect>=0);
return GetShadowMapWidth()>>tr_iShadingMapSizeAspect;
}
PIX CTerrain::GetShadingMapHeight(void)
2016-03-11 14:57:17 +01:00
{
ASSERT(tr_iShadingMapSizeAspect>=0);
return GetShadowMapHeight()>>tr_iShadingMapSizeAspect;
}
// Get reference to layer
CTerrainLayer &CTerrain::GetLayer(INDEX iLayer)
{
INDEX cttl = tr_atlLayers.Count();
ASSERT(iLayer<cttl);
ASSERT(iLayer>=0);
return tr_atlLayers[iLayer];
}
// Add new layer
CTerrainLayer &CTerrain::AddLayer_t(CTFileName fnTexture, LayerType ltType/*=LT_NORMAL*/, BOOL bUpdateTerrain/*=TRUE*/)
{
CTerrainLayer &tl = tr_atlLayers.Push();
// Set layer properties
tl.tl_ltType = ltType;
tl.SetLayerSize(tr_pixHeightMapWidth, tr_pixHeightMapHeight);
tl.SetLayerTexture_t(fnTexture);
// if update terrain flag has been set
if(bUpdateTerrain) {
// Refresh whole terrain
RefreshTerrain();
}
return tl;
}
// Remove one layer
void CTerrain::RemoveLayer(INDEX iLayer, BOOL bUpdateTerrain/*=TRUE*/)
{
CStaticStackArray<class CTerrainLayer> atlLayers;
INDEX cttl = tr_atlLayers.Count();
if(iLayer<0 || iLayer>=cttl) {
ASSERTALWAYS("Invalid layer index");
return;
}
if(iLayer==0 && cttl==1) {
ASSERTALWAYS("Can't remove last layer");
return;
}
// for each exisiting layer
for(INDEX itl=0;itl<cttl;itl++) {
// if this layer index is not same as index of layer that need to be removed
if(itl!=iLayer) {
// Add new layer
CTerrainLayer &tl = atlLayers.Push();
// Copy this layer into new array
tl = tr_atlLayers[itl];
}
}
ASSERT(atlLayers.Count() == cttl-1);
// Clear old layers
tr_atlLayers.Clear();
// Copy new layers insted of old one
tr_atlLayers = atlLayers;
// if update terrain flag has been set
if(bUpdateTerrain) {
// Refresh whole terrain
RefreshTerrain();
}
}
// Move layer to new position
INDEX CTerrain::SetLayerIndex(INDEX iLayer, INDEX iNewIndex, BOOL bUpdateTerrain/*=TRUE*/)
{
CStaticStackArray<class CTerrainLayer> atlLayers;
INDEX cttl = tr_atlLayers.Count();
if(iLayer<0 || iLayer>=cttl) {
ASSERTALWAYS("Invalid layer index");
return iLayer;
}
if(iLayer==0 && cttl==1) {
ASSERTALWAYS("Can't move only layer");
return iLayer;
}
if(iLayer==iNewIndex) {
ASSERTALWAYS("Old layer index is same as new one");
return iLayer;
}
CStaticStackArray<class CTerrainLayer> &atlFrom = tr_atlLayers;
CStaticStackArray<class CTerrainLayer> &atlTo = atlLayers;
atlTo.Push(cttl);
INDEX iOld = iLayer;
INDEX iNew = iNewIndex;
for(INDEX iFrom=0; iFrom<cttl; iFrom++) {
INDEX iTo=-1;
if (iNew==iOld) {
iTo = iFrom;
} if ((iFrom<iOld && iFrom<iNew) || (iFrom>iOld && iFrom>iNew)) {
iTo = iFrom;
} else if (iFrom==iOld) {
iTo = iNew;
} else {
if (iNew>iOld) {
iTo = iFrom-1;
} else {
iTo = iFrom+1;
}
}
atlTo[iTo] = atlFrom[iFrom];
}
ASSERT(atlLayers.Count() == cttl);
// Clear old layers
tr_atlLayers.Clear();
// Copy new layers insted of old one
tr_atlLayers = atlLayers;
// if update terrain flag has been set
if(bUpdateTerrain) {
// Refresh whole terrain
RefreshTerrain();
}
return iNewIndex;
}
// Add tile to reqen queue
void CTerrain::AddTileToRegenQueue(INDEX iTileIndex)
{
INDEX &iRegenIndex = tr_auiRegenList.Push();
CTerrainTile &tt = tr_attTiles[iTileIndex];
iRegenIndex = iTileIndex;
tt.AddFlag(TT_REGENERATE);
}
// Add all tiles to regen queue
void CTerrain::AddAllTilesToRegenQueue()
{
// for each terrain tile
for(INDEX itt=0;itt<tr_ctTiles;itt++) {
// Add tile to reqen queue
CTerrainTile &tt = tr_attTiles[itt];
AddTileToRegenQueue(itt);
}
}
// Clear current regen list
void CTerrain::ClearRegenList(void)
{
tr_auiRegenList.PopAll();
}
void CTerrain::UpdateShadowMap(FLOATaabbox3D *pbboxUpdate/*=NULL*/, BOOL bAbsoluteSpace/*=FALSE*/)
{
// if this is world editor app
if(!_bWorldEditorApp) {
// Shadow map can only be updated from world editor
return;
}
// if shadow update is allowed
if(_wrpWorldRenderPrefs.GetShadowsType()==CWorldRenderPrefs::SHT_FULL) {
// update terrain shadow map
UpdateTerrainShadowMap(this,pbboxUpdate,bAbsoluteSpace);
// don't update shadow map next frame
RemoveFlag(TR_UPDATE_SHADOWMAP);
// else
} else {
// dont update shadow map but remeber that it's not up to date
AddFlag(TR_UPDATE_SHADOWMAP);
}
}
// Temp:
__forceinline void CopyPixel(COLOR *pubSrc,COLOR *pubDst,FLOAT fMaskStrength)
{
GFXColor *pcolSrc = (GFXColor*)pubSrc;
GFXColor *pcolDst = (GFXColor*)pubDst;
pcolSrc->ub.r = Lerp(pcolSrc->ub.r,pcolDst->ub.r,fMaskStrength);
pcolSrc->ub.g = Lerp(pcolSrc->ub.g,pcolDst->ub.g,fMaskStrength);
pcolSrc->ub.b = Lerp(pcolSrc->ub.b,pcolDst->ub.b,fMaskStrength);
pcolSrc->ub.a = 255;
2016-03-11 14:57:17 +01:00
}
static INDEX _ctSavedTopMaps=0;
static void SaveAsTga(CTextureData *ptdTex)
{
INDEX iSize = ptdTex->td_mexWidth * ptdTex->td_mexHeight * 4;
CImageInfo iiHeightMap;
iiHeightMap.ii_Width = ptdTex->td_mexWidth;
iiHeightMap.ii_Height = ptdTex->td_mexHeight;
iiHeightMap.ii_BitsPerPixel = 32;
iiHeightMap.ii_Picture = (UBYTE*)AllocMemory(iSize);
memcpy(&iiHeightMap.ii_Picture[0],&ptdTex->td_pulFrames[0],iSize);
CTString strTopMap = CTString(0,"Temp\\Topmap%d.tga",++_ctSavedTopMaps);
iiHeightMap.SaveTGA_t(strTopMap);
iiHeightMap.Clear();
/*
GFXColor *pacolImage = (GFXColor*)&iiHeightMap.ii_Picture[0];
UWORD *puwHeight = tr_auwHeightMap;
for(INDEX ipix=0;ipix<iSize;ipix++) {
*pacolImage = 0x00000000;
if(bUse16b) {
UWORD *puwData = (UWORD*)&pacolImage[0];
*puwData = *puwHeight;
} else {
UBYTE *pubData = (UBYTE*)&pacolImage[0];
UWORD *puwHData = puwHeight;
*pubData = (UBYTE)(*puwHData>>8);
}
pacolImage++;
puwHeight++;
}
*/
}
static void AddTileLayerToTopMap(CTerrain *ptrTerrain, INDEX iTileIndex, INDEX iLayer)
{
CTerrainLayer &tl = ptrTerrain->tr_atlLayers[iLayer];
CTextureData *ptdSrc = tl.tl_ptdTexture;
CTextureData *ptdDst;
INDEX ctQuadsPerTile = ptrTerrain->tr_ctQuadsInTileRow;
INDEX iOffsetX = 0;
INDEX iOffsetZ = 0;
if(iTileIndex==(-1)) {
ptdDst = &ptrTerrain->tr_tdTopMap;
ctQuadsPerTile = ptrTerrain->tr_ctTilesX * ptrTerrain->tr_ctQuadsInTileRow;
} else {
CTerrainTile &tt = ptrTerrain->tr_attTiles[iTileIndex];
ptdDst = tt.GetTopMap();
iOffsetX = tt.tt_iOffsetX*ctQuadsPerTile;
iOffsetZ = tt.tt_iOffsetZ*ctQuadsPerTile;
}
ULONG *pulFirstInTopMap = ptdDst->td_pulFrames;
UBYTE *pubFirstInLayerMask = tl.tl_aubColors;
// Calculate width and height of quad that will be draw in top map
PIX pixDstQuadWidth = ptdDst->GetPixWidth() / ctQuadsPerTile;
PIX pixSrcQuadWidth = tl.tl_pixTileWidth;
// if dst quad is smaller then one pixel
if(pixDstQuadWidth==0) {
return;
}
ASSERT(tl.tl_ctTilesInRow==tl.tl_ctTilesInCol);
INDEX iSrcMipmap = FastLog2((ptdSrc->GetPixWidth() / tl.tl_ctTilesInRow) / pixDstQuadWidth);
INDEX iSrcMipMapOffset = GetMipmapOffset(iSrcMipmap,ptdSrc->GetPixWidth(),ptdSrc->GetPixHeight());
INDEX iSrcMipWidth = ptdSrc->GetPixWidth() >> iSrcMipmap;
INDEX iSrcMipQuadWidth = pixSrcQuadWidth >> iSrcMipmap;
INDEX iSrcMipQuadHeight = iSrcMipQuadWidth;
ASSERT(pixDstQuadWidth==iSrcMipQuadWidth);
ULONG *pulSrcMip = &ptdSrc->td_pulFrames[iSrcMipMapOffset];
INDEX iMaskIndex = iOffsetX + iOffsetZ*ptrTerrain->tr_pixHeightMapWidth;
INDEX iMaskStepX = ptrTerrain->tr_pixHeightMapWidth - ctQuadsPerTile;
// for each quad in tile
for(INDEX iQuadY=0;iQuadY<ctQuadsPerTile;iQuadY++) {
for(INDEX iQuadX=0;iQuadX<ctQuadsPerTile;iQuadX++) {
UBYTE ubMask = pubFirstInLayerMask[iMaskIndex];
BOOL bFlipX = (ubMask&TL_FLIPX)>>TL_FLIPX_SHIFT;
BOOL bFlipY = (ubMask&TL_FLIPY)>>TL_FLIPY_SHIFT;
BOOL bSwapXY = (ubMask&TL_SWAPXY)>>TL_SWAPXY_SHIFT;
BOOL bVisible = (ubMask&TL_VISIBLE)>>TL_VISIBLE_SHIFT;
INDEX iTile = ubMask&TL_TILE_INDEX;
INDEX iTileX = iTile%tl.tl_ctTilesInRow;
INDEX iTileY = iTile/tl.tl_ctTilesInRow;
// if not visible
if(!bVisible) {
iMaskIndex++;
continue; // skip it
}
ASSERT(iTileX<tl.tl_ctTilesInRow);
ASSERT(iTileY<tl.tl_ctTilesInCol);
INDEX iFirstDstQuadPixel = (iQuadX*pixDstQuadWidth) + iQuadY*pixDstQuadWidth*ptdDst->GetPixWidth();
ULONG *pulDstPixel = &pulFirstInTopMap[iFirstDstQuadPixel];
PIX pixSrc = iTileX*iSrcMipQuadWidth + iTileY*iSrcMipQuadWidth*iSrcMipWidth;
PIX pixDst = 0;
PIX pixDstModulo = ptdDst->GetPixWidth() - pixDstQuadWidth;
PIX pixSrcStepY = iSrcMipWidth;
PIX pixSrcStepX = 1;
if(bFlipY) {
pixSrcStepY = -pixSrcStepY;
pixSrc+=iSrcMipQuadHeight*iSrcMipWidth;
}
if(bFlipX) {
pixSrcStepX = -pixSrcStepX;
pixSrc+=iSrcMipQuadWidth;
}
if(bSwapXY) {
Swap(pixSrcStepX, pixSrcStepY);
}
pixSrcStepY -= pixDstQuadWidth*pixSrcStepX;
// for each pixel in this quad
for(PIX pixY=0;pixY<pixDstQuadWidth;pixY++) {
for(PIX pixX=0;pixX<pixDstQuadWidth;pixX++) {
if((pulSrcMip[pixSrc]&0xFF000000) > 0x80000000) {
pulDstPixel[pixDst] = pulSrcMip[pixSrc];
}
pixSrc+=pixSrcStepX;
pixDst++;
}
pixDst+=pixDstModulo;
pixSrc+=pixSrcStepY;
}
iMaskIndex++;
}
iMaskIndex+=iMaskStepX;
}
}
void CTerrain::UpdateTopMap(INDEX iTileIndex, Rect *prcDest/*=NULL*/)
{
//ReGenerateTopMap(this, iTileIndex);
if(iTileIndex==(-1)) {
ctGlobalTopMaps++;
} else {
ctGeneratedTopMaps++;
}
FIX16_16 fiMaskDiv = 1;
INDEX iFirstInMask = 0;
INDEX iMaskWidth = tr_pixHeightMapWidth;
INDEX iTiling = 1;
INDEX iSrcMipWidth = 1;
// destionation texture (must have set allocated memory)
CTextureData *ptdDest;
// if global top map
if(iTileIndex==(-1)) {
ptdDest = &tr_tdTopMap;
// else tile top map
} else {
CTerrainTile &tt = tr_attTiles[iTileIndex];
ptdDest = tt.GetTopMap();
fiMaskDiv = tr_ctTilesX;
iFirstInMask = iMaskWidth * tt.tt_iOffsetZ * (tr_ctVerticesInTileRow-1) + (tt.tt_iOffsetX * (tr_ctVerticesInTileRow-1));
}
ASSERT(ptdDest->td_pulFrames==NULL);
PrepareSharedTopMapMemory(ptdDest, iTileIndex);
ASSERT(ptdDest!=NULL);
ASSERT(ptdDest->td_pulFrames!=NULL);
// ASSERT(ptdDest->GetPixWidth()>0 && ptdDest->GetPixHeight()>0 && ptdDest->GetPixWidth()==ptdDest->GetPixHeight());
// iTiling = ClampDn(iTiling,(INDEX)1);
// INDEX iSrcMipWidth = ClampDn(ptdDest->GetWidth()/iTiling,(INDEX)1);
INDEX ctLayers = tr_atlLayers.Count();
// for each layer
for(INDEX itl=0;itl<ctLayers;itl++) {
CTerrainLayer &tl = tr_atlLayers[itl];
// if layer isn't visible
if(!tl.tl_bVisible) {
// skip it
continue;
}
if(tl.tl_ltType==LT_TILE) {
AddTileLayerToTopMap(this,iTileIndex,itl);
continue;
}
if(iTileIndex==(-1)) {
// ptdDest = &tr_tdTopMap;
iTiling = (INDEX)(tr_ctTilesX*tr_ctQuadsInTileRow*tl.tl_fStretchX);
// else tile top map
} else {
CTerrainTile &tt = tr_attTiles[iTileIndex];
// ptdDest = tt.GetTopMap();
fiMaskDiv = tr_ctTilesX;
iFirstInMask = iMaskWidth * tt.tt_iOffsetZ * (tr_ctVerticesInTileRow-1)
+ (tt.tt_iOffsetX * (tr_ctVerticesInTileRow-1));
iTiling = (INDEX)(tr_ctQuadsInTileRow*tl.tl_fStretchX);
}
ASSERT(ptdDest->GetPixWidth()>0 && ptdDest->GetPixHeight()>0 && ptdDest->GetPixWidth()==ptdDest->GetPixHeight());
ASSERT(iTiling>=1);
iTiling = ClampDn(iTiling,(INDEX)1);
// get source texture
CTextureData *ptdSrc = tl.tl_ptdTexture;
INDEX iSrcMipWidth = ClampDn( ptdSrc->GetPixWidth() /iTiling, 1L);
INDEX iSrcMipHeight = ClampDn( ptdSrc->GetPixHeight()/iTiling, 1L);
// Get mipmap of source texture
INDEX immW = FastLog2( ptdSrc->GetPixWidth() / iSrcMipWidth);
INDEX immH = FastLog2( ptdSrc->GetPixHeight() / iSrcMipHeight);
// get address of first byte in source mipmap
INDEX imm = Max( immW, immH);
INDEX iMipAdr = GetMipmapOffset(imm,ptdSrc->GetPixWidth(),ptdSrc->GetPixHeight());
// Mask thing
// get first byte in layer mask
UBYTE *ubFirstInMask = &tl.tl_aubColors[iFirstInMask];
// get first byte in edge map
UBYTE *ubFirstInEdgeMap = &tr_aubEdgeMap[iFirstInMask];
FIX16_16 fiHMaskStep = FIX16_16(iMaskWidth-1) / FIX16_16(ptdDest->GetWidth()-1) / fiMaskDiv;
FIX16_16 fiVMaskStep = FIX16_16(iMaskWidth-1) / FIX16_16(ptdDest->GetWidth()-1) / fiMaskDiv;
SLONG xHMaskStep = fiHMaskStep.slHolder;
SLONG xVMaskStep = fiVMaskStep.slHolder;
SLONG xMaskVPos=0;
// get first byte in destination texture
ULONG *pulTexDst = (ULONG*)&ptdDest->td_pulFrames[0];
// get first byte in source texture
ULONG *pulFirstInMipSrc = (ULONG*)&ptdSrc->td_pulFrames[iMipAdr];
// for each row
for(UINT ir=0;ir<ptdDest->GetPixHeight();ir++)
{
// get first byte for src mip texture in this row
ULONG *pulSrcRow = &pulFirstInMipSrc[(ir&(iSrcMipWidth-1))*iSrcMipWidth];//%
INDEX iMaskVPos = (INDEX)(xMaskVPos>>16) * (iMaskWidth);
UBYTE *pubMaskRow = &ubFirstInMask[iMaskVPos];
UBYTE *pubEdgeMaskRow = &ubFirstInEdgeMap[iMaskVPos];
SLONG xMaskHPos = 0;
// for each column
for(UINT ic=0;ic<ptdDest->GetPixWidth();ic++)
{
ULONG *ulSrc = &pulSrcRow[ic&(iSrcMipWidth-1)];
INDEX iMask = (INDEX)(xMaskHPos>>16);
SLONG x1 = (SLONG)(pubMaskRow[iMask+0]) <<0; //NormByteToFixInt(pubMaskRow[iMask]);
SLONG x2 = (SLONG)(pubMaskRow[iMask+1]) <<0; //NormByteToFixInt(pubMaskRow[iMask+1]);
SLONG x3 = (SLONG)(pubMaskRow[iMask+iMaskWidth+0]) <<0;//NormByteToFixInt(pubMaskRow[iMask+iMaskWidth+0]);
SLONG x4 = (SLONG)(pubMaskRow[iMask+iMaskWidth+1]) <<0;//NormByteToFixInt(pubMaskRow[iMask+iMaskWidth+1]);
SLONG xFactH = xMaskHPos - (xMaskHPos&0xFFFF0000);
SLONG xFactV = xMaskVPos - (xMaskVPos&0xFFFF0000);
SLONG xStrengthX1 = (x1<<7) + (SLONG)(((x2-x1)*xFactH)>>9); //Lerp(fi1,fi2,fiFactH);
SLONG xStrengthX2 = (x3<<7) + (SLONG)(((x4-x3)*xFactH)>>9); //Lerp(fi3,fi4,fiFactH);
SLONG xStrength = (xStrengthX1<<1) + (SLONG)((((xStrengthX2>>0)-(xStrengthX1>>0))*xFactV)>>15); //Lerp(fiStrengthX1,fiStrengthX2,fiFactV);
GFXColor *pcolSrc = (GFXColor*)pulTexDst;
GFXColor *pcolDst = (GFXColor*)ulSrc;
pcolSrc->ub.r = (BYTE)( (ULONG)pcolSrc->ub.r + ((((ULONG)pcolDst->ub.r - (ULONG)pcolSrc->ub.r) * xStrength)>>16));
pcolSrc->ub.g = (BYTE)( (ULONG)pcolSrc->ub.g + ((((ULONG)pcolDst->ub.g - (ULONG)pcolSrc->ub.g) * xStrength)>>16));
pcolSrc->ub.b = (BYTE)( (ULONG)pcolSrc->ub.b + ((((ULONG)pcolDst->ub.b - (ULONG)pcolSrc->ub.b) * xStrength)>>16));
pcolSrc->ub.a = pubEdgeMaskRow[iMask];
2016-03-11 14:57:17 +01:00
pulTexDst++;
xMaskHPos += xHMaskStep;
}
xMaskVPos += xVMaskStep;
}
}
// make mipmaps
INDEX ctMipMaps = GetNoOfMipmaps(ptdDest->GetPixWidth(),ptdDest->GetPixHeight());
MakeMipmaps(ctMipMaps, ptdDest->td_pulFrames, ptdDest->GetPixWidth(), ptdDest->GetPixHeight());
#pragma message(">> Fix DitherMipmaps")
INDEX iDithering = 4;
DitherMipmaps(iDithering,ptdDest->td_pulFrames,ptdDest->td_pulFrames,ptdDest->GetPixWidth(),ptdDest->GetPixHeight());
// force topmap upload
ptdDest->SetAsCurrent(0,TRUE);
// Free shared memory
FreeSharedTopMapMemory(ptdDest, iTileIndex);
}
void CTerrain::GetAllTerrainBBox(FLOATaabbox3D &bbox)
{
// Get last quad tree level
INDEX ctqtl = tr_aqtlQuadTreeLevels.Count();
QuadTreeLevel &qtl = tr_aqtlQuadTreeLevels[ctqtl-1];
ASSERT(qtl.qtl_ctNodes==1);
// Get quad tree node for last level
QuadTreeNode &qtn = tr_aqtnQuadTreeNodes[qtl.qtl_iFirstNode];
bbox = qtn.qtn_aabbox;
}
// Get shading color from tex coords in shading map
COLOR CTerrain::GetShadeColor(CShadingInfo *psi)
{
ASSERT(psi!=NULL);
ASSERT(tr_auwShadingMap!=NULL);
PIX pixShadowU = Clamp(psi->si_pixShadowU,0L,GetShadingMapWidth()-2L);
PIX pixShadowV = Clamp(psi->si_pixShadowV,0L,GetShadingMapHeight()-2L);
FLOAT fUDRatio = psi->si_fUDRatio;
FLOAT fLRRatio = psi->si_fLRRatio;
PIX pixWidth = GetShadingMapWidth();
PIX pixShadow = pixShadowU + pixShadowV*pixWidth;
UWORD auwShade[4];
SLONG aslr[4], aslg[4], aslb[4];
auwShade[0] = tr_auwShadingMap[pixShadow];
auwShade[1] = tr_auwShadingMap[pixShadow+1];
auwShade[2] = tr_auwShadingMap[pixShadow+pixWidth+0];
auwShade[3] = tr_auwShadingMap[pixShadow+pixWidth+1];
for(INDEX ish=0;ish<4;ish++) {
aslr[ish] = (auwShade[ish]&0x7C00)>>10;
aslg[ish] = (auwShade[ish]&0x03E0)>> 5;
aslb[ish] = (auwShade[ish]&0x001F)>> 0;
aslr[ish] = (aslr[ish]<<3) | (aslr[ish]>>2);
aslg[ish] = (aslg[ish]<<3) | (aslg[ish]>>2);
aslb[ish] = (aslb[ish]<<3) | (aslb[ish]>>2);
}
SLONG slRed = Lerp( Lerp(aslr[0], aslr[1], fLRRatio), Lerp(aslr[2], aslr[3], fLRRatio), fUDRatio);
SLONG slGreen = Lerp( Lerp(aslg[0], aslg[1], fLRRatio), Lerp(aslg[2], aslg[3], fLRRatio), fUDRatio);
SLONG slBlue = Lerp( Lerp(aslb[0], aslb[1], fLRRatio), Lerp(aslb[2], aslb[3], fLRRatio), fUDRatio);
ULONG ulPixel = ((slRed <<24)&0xFF000000) |
((slGreen<<16)&0x00FF0000) |
((slBlue << 8)&0x0000FF00) | 0xFF;
return ulPixel;
}
// Get plane from given point
FLOATplane3D CTerrain::GetPlaneFromPoint(FLOAT3D &vAbsPoint)
{
ASSERT(tr_penEntity!=NULL);
FLOAT3D vRelPoint = (vAbsPoint-tr_penEntity->en_plPlacement.pl_PositionVector) * !tr_penEntity->en_mRotation;
vRelPoint(1) /= tr_vStretch(1);
vRelPoint(3) /= tr_vStretch(3);
PIX pixX = (PIX) floor(vRelPoint(1));
PIX pixZ = (PIX) floor(vRelPoint(3));
2016-03-11 14:57:17 +01:00
PIX pixWidth = tr_pixHeightMapWidth;
FLOAT fXRatio = vRelPoint(1) - pixX;
FLOAT fZRatio = vRelPoint(3) - pixZ;
INDEX iPix = pixX + pixZ*pixWidth;
BOOL bFacing = (iPix)&1;
FLOAT3D vx0 = FLOAT3D((pixX+0)*tr_vStretch(1),tr_auwHeightMap[iPix] * tr_vStretch(2) ,(pixZ+0)*tr_vStretch(3));
FLOAT3D vx1 = FLOAT3D((pixX+1)*tr_vStretch(1),tr_auwHeightMap[iPix+1] * tr_vStretch(2) ,(pixZ+0)*tr_vStretch(3));
FLOAT3D vx2 = FLOAT3D((pixX+0)*tr_vStretch(1),tr_auwHeightMap[iPix+pixWidth] * tr_vStretch(2) ,(pixZ+1)*tr_vStretch(3));
FLOAT3D vx3 = FLOAT3D((pixX+1)*tr_vStretch(1),tr_auwHeightMap[iPix+pixWidth+1]* tr_vStretch(2) ,(pixZ+1)*tr_vStretch(3));
vx0 = vx0 * tr_penEntity->en_mRotation + tr_penEntity->en_plPlacement.pl_PositionVector;
vx1 = vx1 * tr_penEntity->en_mRotation + tr_penEntity->en_plPlacement.pl_PositionVector;
vx2 = vx2 * tr_penEntity->en_mRotation + tr_penEntity->en_plPlacement.pl_PositionVector;
vx3 = vx3 * tr_penEntity->en_mRotation + tr_penEntity->en_plPlacement.pl_PositionVector;
if(bFacing) {
if(fXRatio>=fZRatio) {
return FLOATplane3D(vx0,vx2,vx1);
} else {
return FLOATplane3D(vx1,vx2,vx3);
}
} else {
if(fXRatio>=fZRatio) {
return FLOATplane3D(vx2,vx3,vx0);
} else {
return FLOATplane3D(vx0,vx3,vx1);
}
}
}
// Sets number of quads in row of one tile
void CTerrain::SetQuadsPerTileRow(INDEX ctQuadsPerTileRow)
{
tr_ctQuadsInTileRow = Clamp(ctQuadsPerTileRow,(INDEX)4,(INDEX)(tr_pixHeightMapWidth-1));
if(tr_ctQuadsInTileRow!=ctQuadsPerTileRow) {
CPrintF("Warning: Quads per tile has been changed from requested %d to %d\n",ctQuadsPerTileRow,tr_ctQuadsInTileRow);
}
// TODO: Assert that it is 2^n
tr_ctVerticesInTileRow = tr_ctQuadsInTileRow+1;
}
// Set Terrain stretch
void CTerrain::SetTerrainStretch(FLOAT3D vStretch)
{
tr_vStretch = vStretch;
}
// Build terrain data
void CTerrain::BuildTerrainData()
{
// Allocate space for terrain tiles
tr_ctTilesX = (tr_pixHeightMapWidth-1) / tr_ctQuadsInTileRow;
tr_ctTilesY = (tr_pixHeightMapHeight-1) / tr_ctQuadsInTileRow;
tr_ctTiles = tr_ctTilesX*tr_ctTilesY;
tr_attTiles.New(tr_ctTiles);
// Calculate max posible lod
INDEX ctVtxInLod = tr_ctQuadsInTileRow;
tr_iMaxTileLod = 0;
while(ctVtxInLod>2) {
tr_iMaxTileLod++;
ctVtxInLod = ctVtxInLod>>1;
}
// Allocate memory for terrain tile arrays
tr_aArrayHolders.New(tr_iMaxTileLod+1);
INDEX ctah = tr_aArrayHolders.Count();
// for each array handler
for(INDEX iah=0;iah<ctah;iah++) {
CArrayHolder &ah = tr_aArrayHolders[iah];
// set its lod index
ah.ah_iLod = iah;
ah.ah_ptrTerrain = this;
}
// for each tile row
for(INDEX iy=0;iy<tr_ctTilesY;iy++) {
// for each tile col
for(INDEX ix=0;ix<tr_ctTilesX;ix++) {
// Initialize terrain tile
UINT iTileIndex = ix+iy*tr_ctTilesX;
CTerrainTile &tt = tr_attTiles[iTileIndex];
tt.tt_iIndex = iTileIndex;
tt.tt_iOffsetX = ix;
tt.tt_iOffsetZ = iy;
tt.tt_ctVtxX = tr_ctVerticesInTileRow;
tt.tt_ctVtxY = tr_ctVerticesInTileRow;
tt.tt_ctLodVtxX = tt.tt_ctVtxX;
tt.tt_ctLodVtxY = tt.tt_ctVtxY;
tt.tt_iLod = 0;
tt.tt_fLodLerpFactor = 0;
// Reset tile neighbours
tt.tt_aiNeighbours[NB_TOP] =-1; tt.tt_aiNeighbours[NB_LEFT] =-1;
tt.tt_aiNeighbours[NB_BOTTOM]=-1; tt.tt_aiNeighbours[NB_RIGHT] =-1;
// Set tile neighbours
if(iy>0) tt.tt_aiNeighbours[NB_TOP] = iTileIndex-tr_ctTilesX;
if(ix>0) tt.tt_aiNeighbours[NB_LEFT] = iTileIndex-1;
if(iy<tr_ctTilesX-1) tt.tt_aiNeighbours[NB_BOTTOM] = iTileIndex+tr_ctTilesX;
if(ix<tr_ctTilesY-1) tt.tt_aiNeighbours[NB_RIGHT] = iTileIndex+1;
}
}
}
/*
#if 1
void CTerrain::GenerateTopMap(INDEX iTileIndex)
{
FIX16_16 fiMaskDiv = 1;
INDEX iFirstInMask = 0;
INDEX iMaskWidth = tr_pixHeightMapWidth;
INDEX iTiling = (INDEX)(tr_ctTilesX*tr_ctQuadsInTileRow*tr_fTexStretch);
// destionation texture (must have set allocated memory)
CTextureData *ptdDest;
// if global top map
if(iTileIndex==(-1)) {
ptdDest = &tr_tdTopMap;
// else tile top map
} else {
CTerrainTile &tt = tr_attTiles[iTileIndex];
ptdDest = tt.GetTopMap();
fiMaskDiv = tr_ctTilesX;
iFirstInMask = iMaskWidth * tt.tt_iOffsetZ * (tr_ctVerticesInTileRow-1) + (tt.tt_iOffsetX * (tr_ctVerticesInTileRow-1));
iTiling = (INDEX)(tr_ctQuadsInTileRow*tr_fTexStretch);
}
ASSERT(ptdDest->GetPixWidth()>0 && ptdDest->GetPixHeight()>0 && ptdDest->GetPixWidth()==ptdDest->GetPixHeight());
INDEX iSrcMipWidth = ClampDn(ptdDest->GetWidth()/iTiling,(INDEX)1);
INDEX ctLayers = tr_atlLayers.Count();
// for each layer
for(INDEX itl=0;itl<ctLayers;itl++) {
CTerrainLayer &tl = tr_atlLayers[itl];
// get source texture
CTextureData *ptdSrc = tl.tl_ptdTexture;
// Get mipmap of source texture
INDEX imm = FastLog2(ptdSrc->GetPixWidth()/iSrcMipWidth);
// get address of first byte in source mipmap
INDEX iMipAdr = GetMipmapOffset(imm,ptdSrc->GetPixWidth(),ptdSrc->GetPixHeight());
// Mask thing
// get first byte in layer mask
UBYTE *ubFirstInMask = &tl.tl_aubColors[iFirstInMask];
FIX16_16 fiHMaskStep = FIX16_16(iMaskWidth-1)/FIX16_16(ptdDest->GetWidth()-1)/fiMaskDiv;
FIX16_16 fiVMaskStep = FIX16_16(iMaskWidth-1)/FIX16_16(ptdDest->GetWidth()-1)/fiMaskDiv;
SLONG xHMaskStep = fiHMaskStep.slHolder;
SLONG xVMaskStep = fiVMaskStep.slHolder;
SLONG xMaskVPos=0;
// get first byte in destination texture
ULONG *pulTexDst = (ULONG*)&ptdDest->td_pulFrames[0];
// get first byte in source texture
ULONG *pulFirstInMipSrc = (ULONG*)&ptdSrc->td_pulFrames[iMipAdr];
// for each row
for(UINT ir=0;ir<ptdDest->GetHeight();ir++) {
// get first byte for src mip texture in this row
ULONG *pulSrcRow = &pulFirstInMipSrc[(ir&(iSrcMipWidth-1))*iSrcMipWidth];//%
INDEX iMaskVPos = (INDEX)(xMaskVPos>>16) * (iMaskWidth);
UBYTE *pubMaskRow = &ubFirstInMask[iMaskVPos];
SLONG xMaskHPos = 0;
// for each column
for(UINT ic=0;ic<ptdDest->GetWidth();ic++) {
ULONG *ulSrc = &pulSrcRow[ic&(iSrcMipWidth-1)];
INDEX iMask = (INDEX)(xMaskHPos>>16);
SLONG x1 = (SLONG)(pubMaskRow[iMask+0]) <<0; //NormByteToFixInt(pubMaskRow[iMask]);
SLONG x2 = (SLONG)(pubMaskRow[iMask+1]) <<0; //NormByteToFixInt(pubMaskRow[iMask+1]);
SLONG x3 = (SLONG)(pubMaskRow[iMask+iMaskWidth+0]) <<0;//NormByteToFixInt(pubMaskRow[iMask+iMaskWidth+0]);
SLONG x4 = (SLONG)(pubMaskRow[iMask+iMaskWidth+1]) <<0;//NormByteToFixInt(pubMaskRow[iMask+iMaskWidth+1]);
SLONG xFactH = xMaskHPos - (xMaskHPos&0xFFFF0000);
SLONG xFactV = xMaskVPos - (xMaskVPos&0xFFFF0000);
SLONG xStrengthX1 = (x1<<7) + (SLONG)(((x2-x1)*xFactH)>>9); //Lerp(fi1,fi2,fiFactH);
SLONG xStrengthX2 = (x3<<7) + (SLONG)(((x4-x3)*xFactH)>>9); //Lerp(fi3,fi4,fiFactH);
SLONG xStrength = (xStrengthX1<<1) + (SLONG)((((xStrengthX2>>0)-(xStrengthX1>>0))*xFactV)>>15); //Lerp(fiStrengthX1,fiStrengthX2,fiFactV);
GFXColor *pcolSrc = (GFXColor*)pulTexDst;
GFXColor *pcolDst = (GFXColor*)ulSrc;
pcolSrc->r = (BYTE)( (ULONG)pcolSrc->r + ((((ULONG)pcolDst->r - (ULONG)pcolSrc->r) * xStrength)>>16));
pcolSrc->g = (BYTE)( (ULONG)pcolSrc->g + ((((ULONG)pcolDst->g - (ULONG)pcolSrc->g) * xStrength)>>16));
pcolSrc->b = (BYTE)( (ULONG)pcolSrc->b + ((((ULONG)pcolDst->b - (ULONG)pcolSrc->b) * xStrength)>>16));
pcolSrc->a = 255;
pulTexDst++;
xMaskHPos += xHMaskStep;
}
xMaskVPos += xVMaskStep;
}
}
// make mipmaps
MakeMipmaps(32, ptdDest->td_pulFrames, ptdDest->GetWidth(), ptdDest->GetHeight());
// force topmap upload
ptdDest->SetAsCurrent(0,TRUE);
}
#else
void CTerrain::GenerateTopMap(INDEX iTileIndex)
{
INDEX iMaskDiv = 1;
INDEX iFirstInMask = 0;
INDEX iMaskWidth = tr_pixHeightMapWidth;
INDEX iTiling = (INDEX)(tr_ctTilesX*tr_ctQuadsInTileRow*tr_fTexStretch);
// destionation texture (must have set required width and height)
CTextureData *ptdDest;
// if global top map
if(iTileIndex==(-1)) {
ptdDest = &tr_tdTopMap;
// else tile top map
} else {
CTerrainTile &tt = tr_attTiles[iTileIndex];
ptdDest = &tt.GetTopMap();
iMaskDiv = tr_ctTilesX;
iFirstInMask = iMaskWidth * tt.tt_iOffsetZ * (tr_ctVerticesInTileRow-1) + (tt.tt_iOffsetX * (tr_ctVerticesInTileRow-1));
iTiling = (INDEX)(tr_ctQuadsInTileRow*tr_fTexStretch);
}
ASSERT(ptdDest->GetPixWidth()>0 && ptdDest->GetPixHeight()>0 && ptdDest->GetPixWidth()==ptdDest->GetPixHeight());
INDEX iSrcMipWidth = ptdDest->GetWidth()/iTiling;
INDEX ctLayers = tr_atlLayers.Count();
// for each layer
for(INDEX ilr=0;ilr<ctLayers;ilr++) {
CTerrainLayer &tl = tr_atlLayers[ilr];
// get source texture
CTextureData *ptdSrc = tl.tl_ptdTexture;
// Get mipmap of source texture
INDEX imm = FastLog2(ptdSrc->GetPixWidth()/iSrcMipWidth);
// get address of first byte in source mipmap
INDEX iMipAdr = GetMipmapOffset(imm,ptdSrc->GetPixWidth(),ptdSrc->GetPixHeight());
// Mask thing
// get first byte in layer mask
UBYTE *ubFirstInMask = &tl.tl_aubColors[iFirstInMask];
FLOAT fHMaskStep = FLOAT(iMaskWidth-1)/(ptdDest->GetWidth()-1)/iMaskDiv;
FLOAT fVMaskStep = FLOAT(iMaskWidth-1)/(ptdDest->GetWidth()-1)/iMaskDiv;
FLOAT fMaskVPos=0;
// get first byte in destination texture
ULONG *pulTexDst = (ULONG*)&ptdDest->td_pulFrames[0];
// get first byte in source texture
ULONG *pulFirstInMipSrc = &ptdSrc->td_pulFrames[iMipAdr];
// for each row
for(UINT ir=0;ir<ptdDest->GetWidth();ir++) {
// get first byte for src mip texture in this row
ULONG *pulSrcRow = &pulFirstInMipSrc[(ir&(iSrcMipWidth-1))*iSrcMipWidth];//%
INDEX iMaskVPos = (INDEX)fMaskVPos * (iMaskWidth);
UBYTE *pubMaskRow = &ubFirstInMask[iMaskVPos];
FLOAT fMaskHPos = 0;
// for each column
for(UINT ic=0;ic<ptdDest->GetWidth();ic++) {
ULONG *ulSrc = &pulSrcRow[ic&(iSrcMipWidth-1)];
INDEX iMask = (INDEX)fMaskHPos;
FLOAT f1 = NormByteToFloat(pubMaskRow[iMask]);
FLOAT f2 = NormByteToFloat(pubMaskRow[iMask+1]);
FLOAT f3 = NormByteToFloat(pubMaskRow[iMask+iMaskWidth+0]);
FLOAT f4 = NormByteToFloat(pubMaskRow[iMask+iMaskWidth+1]);
FLOAT fStrengthX1 = Lerp(f1,f2,fMaskHPos-(INDEX)fMaskHPos);
FLOAT fStrengthX2 = Lerp(f3,f4,fMaskHPos-(INDEX)fMaskHPos);
FLOAT fStrength = Lerp(fStrengthX1,fStrengthX2,fMaskVPos-(INDEX)fMaskVPos);
CopyPixel(pulTexDst,ulSrc,fStrength);
pulTexDst++;
fMaskHPos+=fHMaskStep;
}
fMaskVPos+=fVMaskStep;
}
}
// make mipmaps
MakeMipmaps( 32, ptdDest->td_pulFrames, ptdDest->GetWidth(), ptdDest->GetHeight());
// force topmap upload
ptdDest->SetAsCurrent(0,TRUE);
}
#endif
*/
void CTerrain::GenerateTerrainTopMap()
{
CreateTopMap(tr_tdTopMap,tr_pixTopMapWidth,tr_pixTopMapHeight);
UpdateTopMap(-1);
}
// Add default layer
void CTerrain::AddDefaultLayer_t(void)
{
// Add one layer using default texture, but do not refresh terrain
CTerrainLayer &tl = AddLayer_t((CTString)"Textures\\Editor\\Default.TEX", LT_NORMAL, FALSE);
// fill this layer
tl.ResetLayerMask(255);
}
// Build quadtree for terrain
void CTerrain::BuildQuadTree(void)
{
INDEX ctQuadNodeRows = tr_ctTilesX;
INDEX ctQuadNodeCols = tr_ctTilesY;
INDEX ctQuadNodes = 0;
// Create quad tree levels
while(TRUE) {
QuadTreeLevel &qtl = tr_aqtlQuadTreeLevels.Push();
// Remember first node
qtl.qtl_iFirstNode = ctQuadNodes;
// Add nodes in this level to total node count
ctQuadNodes += ClampDn(ctQuadNodeRows,(INDEX)1) * ClampDn(ctQuadNodeCols,(INDEX)1);
// Count nodes in this level
qtl.qtl_ctNodes = ctQuadNodes - qtl.qtl_iFirstNode;
qtl.qtl_ctNodesCol = ctQuadNodeCols;
qtl.qtl_ctNodesRow = ctQuadNodeRows;
// if only one node is in this level
if(qtl.qtl_ctNodes == 1) {
// this is last level so exit loop
break;
}
if(ctQuadNodeCols%2 == 1 && ctQuadNodeCols != 1) {
ctQuadNodeCols = (ctQuadNodeCols+1)>>1;
} else {
ctQuadNodeCols = ctQuadNodeCols>>1;
}
if(ctQuadNodeRows%2 == 1 && ctQuadNodeRows != 1) {
ctQuadNodeRows = (ctQuadNodeRows+1)>>1;
} else {
ctQuadNodeRows = ctQuadNodeRows>>1;
}
}
QuadTreeLevel &qtlFirst = tr_aqtlQuadTreeLevels[0];
// Add quadtree nodes for first level
tr_aqtnQuadTreeNodes.Push(qtlFirst.qtl_ctNodes);
// for each quad tree node in first level
for(INDEX iqn=0;iqn<qtlFirst.qtl_ctNodes;iqn++) {
// Generate vertices for tile in first lod with no vertex lerping
CTerrainTile &tt = tr_attTiles[iqn];
QuadTreeNode &qtn = tr_aqtnQuadTreeNodes[iqn];
tt.tt_iLod = -1;
tt.tt_iRequestedLod = 0;
tt.tt_fLodLerpFactor = 0;
tt.AddFlag(TT_REGENERATE|TT_NO_TOPMAP_REGEN);
ReGenerateTile(iqn);
tt.RemoveFlag(TT_REGENERATE|TT_NO_TOPMAP_REGEN);
// Set quad tree bbox as first vertex in tile
GFXVertex4 &vtxFirst = tt.GetVertices()[0];
qtn.qtn_aabbox = FLOATaabbox3D(FLOAT3D(vtxFirst.x,vtxFirst.y,vtxFirst.z));
// for each vertex after first
INDEX ctVtx = tt.GetVertices().Count();
for(INDEX ivx=1;ivx<ctVtx;ivx++) {
// Add vertex in quad tree node bbox
GFXVertex4 &vtx = tt.GetVertices()[ivx];
qtn.qtn_aabbox |= FLOATaabbox3D(FLOAT3D(vtx.x,vtx.y,vtx.z));
}
// release arrays of tile
tt.ReleaseTileArrays();
tt.tt_iLod = -1;
tt.tt_iRequestedLod = 0;
qtn.qtn_iTileIndex = iqn;
// nodes in first level does not have children
qtn.qtn_iChild[0] = -1;
qtn.qtn_iChild[1] = -1;
qtn.qtn_iChild[2] = -1;
qtn.qtn_iChild[3] = -1;
}
// Create all other levels of quad tree
INDEX ctQuadLevels = tr_aqtlQuadTreeLevels.Count();
// for each quadtree level after first
for(INDEX iql=1;iql<ctQuadLevels;iql++) {
QuadTreeLevel &qtl = tr_aqtlQuadTreeLevels[iql];
QuadTreeLevel &qtlPrev = tr_aqtlQuadTreeLevels[iql-1];
// for each quadtree node row
for(INDEX ir=0;ir<qtlPrev.qtl_ctNodesRow;ir+=2) {
// for each quadtree node col
for(INDEX ic=0;ic<qtlPrev.qtl_ctNodesCol;ic+=2) {
// Set quadtree node children
INDEX iqt = qtlPrev.qtl_iFirstNode + ic+ir*qtlPrev.qtl_ctNodesCol;
QuadTreeNode &qtn = tr_aqtnQuadTreeNodes.Push();
QuadTreeNode *pqtnFirst = &tr_aqtnQuadTreeNodes[iqt];
// Set first child node
qtn.qtn_aabbox = pqtnFirst->qtn_aabbox;
qtn.qtn_iChild[0] = iqt;
qtn.qtn_iChild[1] = -1;
qtn.qtn_iChild[2] = -1;
qtn.qtn_iChild[3] = -1;
qtn.qtn_iTileIndex = -1;
// If second child node exists
if(ic+1<qtlPrev.qtl_ctNodesCol) {
// Set second child
qtn.qtn_iChild[1] = iqt+1;
qtn.qtn_aabbox |= pqtnFirst[1].qtn_aabbox;
}
// if fourth child exist
if(ir+1<qtlPrev.qtl_ctNodesRow) {
// Set third child
qtn.qtn_iChild[2] = iqt+qtlPrev.qtl_ctNodesCol;
qtn.qtn_aabbox |= pqtnFirst[qtlPrev.qtl_ctNodesCol].qtn_aabbox;
// Set fourth child
if(ic+1<qtlPrev.qtl_ctNodesCol) {
qtn.qtn_iChild[3] = iqt+qtlPrev.qtl_ctNodesCol+1;
qtn.qtn_aabbox |= pqtnFirst[qtlPrev.qtl_ctNodesCol+1].qtn_aabbox;
}
}
}
}
}
}
// Update higher quadtree levels from first one
void CTerrain::UpdateQuadTree()
{
// for all quad tree levels after first one
INDEX ctqtl=tr_aqtlQuadTreeLevels.Count();
for(INDEX iqtl=1;iqtl<ctqtl;iqtl++) {
QuadTreeLevel &qtl = tr_aqtlQuadTreeLevels[iqtl];
// for each quad tree node in this level
INDEX ctqtn=qtl.qtl_iFirstNode+qtl.qtl_ctNodes;
for(INDEX iqtn=qtl.qtl_iFirstNode;iqtn<ctqtn;iqtn++) {
QuadTreeNode &qtn = tr_aqtnQuadTreeNodes[iqtn];
// trash qtn box
qtn.qtn_aabbox.maxvect = FLOAT3D(-1,-1,-1);
qtn.qtn_aabbox.minvect = FLOAT3D( 1, 1, 1);
// for each child of qtn
for(INDEX ichild=0;ichild<4;ichild++) {
INDEX iqtnChild = qtn.qtn_iChild[ichild];
// if child exists
if(iqtnChild!=(-1)) {
QuadTreeNode &qtnChild = tr_aqtnQuadTreeNodes[iqtnChild];
// if qtn box is empty
if(qtn.qtn_aabbox.IsEmpty()) {
// set qtn box as box of this child
qtn.qtn_aabbox = qtnChild.qtn_aabbox;
// if it had some data
} else {
// just add child box to qtn box
qtn.qtn_aabbox |= qtnChild.qtn_aabbox;
}
}
}
}
}
}
/*
* Generation
*/
void CTerrain::ReGenerate(void)
{
// for each tile in terrain
for(INDEX it=0;it<tr_ctTiles;it++) {
CTerrainTile &tt = tr_attTiles[it];
// calculate new lod
tt.tt_iRequestedLod = tt.CalculateLOD();
}
// for each tile that is waiting in regen queue
INDEX ctrt = tr_auiRegenList.Count();
INDEX irt;
for(irt=0;irt<ctrt;irt++) {
2016-03-11 14:57:17 +01:00
// mark tile as ready for regeneration
INDEX iTileIndex = tr_auiRegenList[irt];
CTerrainTile &tt = tr_attTiles[iTileIndex];
tt.AddFlag(TT_REGENERATE);
}
// for each tile that is waiting in regen queue
for(irt=0;irt<ctrt;irt++) {
INDEX iTileIndex = tr_auiRegenList[irt];
CTerrainTile &tt = tr_attTiles[iTileIndex];
// if tile needs to be regenerated
if(tt.GetFlags() & TT_REGENERATE) {
// Regenerate it now
ReGenerateTile(tt.tt_iIndex);
// remove flag for regeneration
tt.RemoveFlag(TT_REGENERATE);
}
}
// clear regenration list
ClearRegenList();
}
extern CStaticStackArray<GFXVertex4> _avLerpedVerices;
static void ShowTerrainInfo(CAnyProjection3D &apr, CDrawPort *pdp, CTerrain *ptrTerrain)
{
pdp->SetFont( _pfdConsoleFont);
pdp->SetTextAspect( 1.0f);
pdp->SetOrtho();
CTString strInfo;
INDEX ctTopMaps = ptrTerrain->tr_atdTopMaps.Count() + 1;
strInfo.PrintF("Tris = %d\nNodes = %d\nDelayed nodes = %d\nTop maps = %d\nTexgens = %d, %d\nShadowmap updates = %d\n",
_ctTris,_ctNodesVis,_ctDelayedNodes,ctTopMaps,ctGeneratedTopMaps,ctGlobalTopMaps,_ctShadowMapUpdates);
CStaticStackArray<INDEX> iaLodInfo;
iaLodInfo.Push(ptrTerrain->tr_iMaxTileLod+1);
memset(&iaLodInfo[0],0,sizeof(INDEX)*iaLodInfo.sa_Count);
// build lod info
for(INDEX it=0;it<ptrTerrain->tr_ctTiles;it++) {
CTerrainTile &tt = ptrTerrain->tr_attTiles[it];
INDEX &ili = iaLodInfo[tt.tt_iLod];
ili++;
}
// Show how many tiles are in witch lod
CTString strTemp = "LodInfo:\n";
for(INDEX itti=0;itti<ptrTerrain->tr_iMaxTileLod+1;itti++) {
CTString str;
CArrayHolder &ah = ptrTerrain->tr_aArrayHolders[itti];
str.PrintF("L%d = mem = %d KB, nodes = %d\n",itti, ah.GetUsedMemory()/1024, iaLodInfo[itti]);
strTemp += str;
}
strTemp += "\n";
strInfo +=strTemp;
// Show memory usage
SLONG slUsedMemory=0;
// Height map usage
SLONG slHeightMap = ptrTerrain->tr_pixHeightMapWidth*ptrTerrain->tr_pixHeightMapHeight*sizeof(UWORD);
// Edge map usage
SLONG slEdgeMap = ptrTerrain->tr_pixHeightMapWidth*ptrTerrain->tr_pixHeightMapHeight*sizeof(UBYTE);
// Shadow map usage
SLONG slShadowMap = ptrTerrain->tr_tdShadowMap.GetUsedMemory();
// Quad tree usage
SLONG slQTNodes = sizeof(QuadTreeNode)*ptrTerrain->tr_aqtnQuadTreeNodes.Count();
SLONG slQTLevels = sizeof(QuadTreeLevel)*ptrTerrain->tr_aqtlQuadTreeLevels.Count();
// Tiles usage
SLONG slTiles = 0;
INDEX cttt = ptrTerrain->tr_ctTiles;
for(INDEX itt=0;itt<cttt;itt++) {
CTerrainTile &tt = ptrTerrain->tr_attTiles[itt];
slTiles+=tt.GetUsedMemory();
}
// Arrays holders usage
SLONG slArrayHoldes=0;
INDEX ctah=ptrTerrain->tr_aArrayHolders.Count();
for(INDEX iah=0;iah<ctah;iah++) {
CArrayHolder &ah = ptrTerrain->tr_aArrayHolders[iah];
slArrayHoldes+=ah.GetUsedMemory();
}
SLONG slLayers=0;
// Terrain layers usage
INDEX cttl = ptrTerrain->tr_atlLayers.Count();
for(INDEX itl=0;itl<cttl;itl++) {
CTerrainLayer &tl = ptrTerrain->tr_atlLayers[itl];
slLayers+=tl.GetUsedMemory();
}
SLONG slTopMaps=0;
// Top maps usage
INDEX cttm=ptrTerrain->tr_atdTopMaps.Count();
for(INDEX itm=0;itm<cttm;itm++) {
CTextureData *ptdTopMap = &ptrTerrain->tr_atdTopMaps[itm];
slTopMaps+=ptdTopMap->GetUsedMemory();
}
SLONG slGlobalTopMap = ptrTerrain->tr_tdTopMap.GetUsedMemory();
SLONG slTileBatchingSize = GetUsedMemoryForTileBatching();
SLONG slVertexSmoothing = _avLerpedVerices.sa_Count * sizeof(GFXVertex4);
extern SLONG _slSharedTopMapSize; // Shared top map size
// Global top map usage
SLONG slTotal = slHeightMap+slEdgeMap+slShadowMap+slQTNodes+slQTLevels+slTiles+slArrayHoldes+slLayers+
slTopMaps+slGlobalTopMap+slTileBatchingSize+slVertexSmoothing;
CTString strMemoryUsed;
strMemoryUsed.PrintF("Heightmap = %d KB\nEdgemap = %d KB\nShadowMap = %d KB\nQuadTree = %d KB\nTiles = %d KB\nArrays = %d KB\nLayers = %d KB\nTopMaps = %d KB\nGlobal TM = %d KB\nShared TM = %d KB\nVtx lerp = %d KB\nBatching = %d KB\nTotal = %d KB\n",
slHeightMap/1024,slEdgeMap/1024,slShadowMap/1024,(slQTNodes+slQTLevels)/1024,slTiles/1024,slArrayHoldes/1024,slLayers/1024,slTopMaps/1024,slGlobalTopMap/1024,_slSharedTopMapSize/1024,slVertexSmoothing/1024,slTileBatchingSize/1024,slTotal/1024);
strInfo += strMemoryUsed;
extern FLOAT3D _vDirection;
strInfo += CTString(0,"Shadow map size = %d,%d [%d]\nShading map size= %d,%d [%d]\n",
ptrTerrain->GetShadowMapWidth(), ptrTerrain->GetShadowMapHeight(),
ptrTerrain->tr_iShadowMapSizeAspect,ptrTerrain->GetShadingMapWidth(),
ptrTerrain->GetShadingMapHeight(),ptrTerrain->tr_iShadingMapSizeAspect);
pdp->PutText(strInfo,0,40);
}
static void ReadOldShadowMap(CTerrain *ptrTerrain, CTStream *istrFile)
{
// Read terrain shadow map
// Read shadow map size
INDEX pixShadowMapWidth;
INDEX pixShadowMapHeight;
(*istrFile)>>pixShadowMapWidth;
(*istrFile)>>pixShadowMapHeight;
BOOL bHaveShadowMap;
(*istrFile)>>bHaveShadowMap;
// is shadow map saved
if(bHaveShadowMap) {
// skip reading of first mip of shadow map
istrFile->Seek_t(pixShadowMapWidth*pixShadowMapHeight*sizeof(GFXColor),CTStream::SD_CUR);
//istrFile->Read_t(&tr_tdShadowMap.td_pulFrames[0],tr_pixShadowMapWidth*tr_pixShadowMapHeight*sizeof(GFXColor));
}
// Set default shadow map size
ptrTerrain->SetShadowMapsSize(0,0);
}
void CTerrain::ReadVersion_t( CTStream *istrFile, INDEX iSavedVersion)
{
// set current terrain
_ptrTerrain = this;
ASSERT(_CrtCheckMemory());
PIX pixWidth;
PIX pixHeight;
// read height map width and height
(*istrFile)>>pixWidth;
(*istrFile)>>pixHeight;
// Reallocate memory for terrain with size
AllocateHeightMap(pixWidth,pixHeight);
// read terrain stretch
(*istrFile)>>tr_vStretch;
// read texture stretch
if(iSavedVersion<6) {
FLOAT fTemp; // Read temp stretch
(*istrFile)>>fTemp;
}
// read lod distance factor
(*istrFile)>>tr_fDistFactor;
if(iSavedVersion>6) {
// Read terrain size
(*istrFile)>>tr_vTerrainSize;
istrFile->ExpectID_t("TRSM"); // 'Terrain shadowmap'
// if version is smaller than 8
if(iSavedVersion<8) {
// read old shadow map format
ReadOldShadowMap(this,istrFile);
} else {
INDEX iShadowMapAspect;
INDEX iShadingMapAspect;
(*istrFile)>>iShadowMapAspect;
(*istrFile)>>iShadingMapAspect;
SetShadowMapsSize(iShadowMapAspect,iShadingMapAspect);
INDEX iShadowMapSize = GetShadowMapWidth() * GetShadowMapHeight();
INDEX iShadingMapSize = GetShadingMapWidth() * GetShadingMapHeight();
2016-03-11 14:57:17 +01:00
// Read shadow map
ASSERT(tr_tdShadowMap.td_pulFrames!=NULL);
for (INDEX i = 0; i < iShadowMapSize; i++)
(*istrFile)>>tr_tdShadowMap.td_pulFrames[i];
2016-03-11 14:57:17 +01:00
// Read shading map
ASSERT(tr_auwShadingMap!=NULL);
for (INDEX i = 0; i < iShadingMapSize; i++)
(*istrFile)>>tr_auwShadingMap[i];
2016-03-11 14:57:17 +01:00
}
// Create shadow map mipmaps
INDEX ctMipMaps = GetNoOfMipmaps(GetShadowMapWidth(),GetShadowMapHeight());
MakeMipmaps(ctMipMaps, tr_tdShadowMap.td_pulFrames, GetShadowMapWidth(), GetShadowMapHeight());
// Upload shadow map
tr_tdShadowMap.SetAsCurrent(0,TRUE);
istrFile->ExpectID_t("TSEN"); // 'Terrain shadowmap end'
// if there is edge map saved
if(istrFile->PeekID_t()==CChunkID("TREM")) { // 'Terrain edge map'
// Read terrain edge map
istrFile->ExpectID_t("TREM"); // 'Terrain edge map'
// read edge map
istrFile->Read_t(&tr_aubEdgeMap[0],tr_pixHeightMapWidth*tr_pixHeightMapHeight);
istrFile->ExpectID_t("TEEN"); // 'Terrain edge map end'
}
}
(*istrFile).ExpectID_t("TRHM"); // 'Terrain heightmap'
// read height map
for (ULONG i = 0; i < tr_pixHeightMapWidth*tr_pixHeightMapHeight; i++)
(*istrFile)>>tr_auwHeightMap[i];
2016-03-11 14:57:17 +01:00
(*istrFile).ExpectID_t("THEN"); // 'Terrain heightmap end'
// Terrain will be rebuild in entity.cpp
_ptrTerrain = NULL;
}
// Read from stream.
void CTerrain::Read_t( CTStream *istrFile)
{
(*istrFile).ExpectID_t("TERR"); // 'Terrain'
// read the version number
INDEX iSavedVersion;
(*istrFile)>>iSavedVersion;
// is this version 6
if(iSavedVersion>4) {
ReadVersion_t(istrFile,iSavedVersion);
// else unknown version
} else {
// report error
ThrowF_t( TRANS("The terrain version on disk is %d.\n"
"Current supported version is %d."), iSavedVersion, _iTerrainVersion);
}
// Read Terrain layers
(*istrFile).ExpectID_t("TRLR"); // 'Terrain layers'
// Read terrain layers
INDEX cttl;
(*istrFile)>>cttl;
// Create layers
tr_atlLayers.Push(cttl);
// for each terrain layer
for(INDEX itl=0;itl<cttl;itl++) {
// Read layer texture and mask
CTerrainLayer &tl = tr_atlLayers[itl];
tl.Read_t(istrFile,iSavedVersion);
}
(*istrFile).ExpectID_t("TLEN"); // 'Terrain layers end'
// End of reading
(*istrFile).ExpectID_t("TREN"); // 'terrain end'
}
// Write to stream.
void CTerrain::Write_t( CTStream *ostrFile)
{
(*ostrFile).WriteID_t("TERR"); // 'Terrain'
// write the terrain version
(*ostrFile)<<_iTerrainVersion;
// write height map width and height
(*ostrFile)<<tr_pixHeightMapWidth;
(*ostrFile)<<tr_pixHeightMapHeight;
// write terrain stretch
(*ostrFile)<<tr_vStretch;
// write lod distance factor
(*ostrFile)<<tr_fDistFactor;
// Write terrain size
(*ostrFile)<<tr_vTerrainSize;
// Write terrain shadow map
ostrFile->WriteID_t("TRSM"); // 'Terrain shadowmap'
(*ostrFile)<<tr_iShadowMapSizeAspect;
(*ostrFile)<<tr_iShadingMapSizeAspect;
INDEX iShadowMapSize = GetShadowMapWidth() * GetShadowMapHeight() * sizeof(ULONG);
INDEX iShadingMapSize = GetShadingMapWidth() * GetShadingMapHeight() * sizeof(UWORD);
// Write shadow map
ASSERT(tr_tdShadowMap.td_pulFrames!=NULL);
ostrFile->Write_t(&tr_tdShadowMap.td_pulFrames[0],iShadowMapSize);
// Write shading map
ASSERT(tr_auwShadingMap!=NULL);
ostrFile->Write_t(&tr_auwShadingMap[0],iShadingMapSize);
ostrFile->WriteID_t("TSEN"); // 'Terrain shadowmap end'
// if edge map exists
if(tr_aubEdgeMap!=NULL) {
ostrFile->WriteID_t("TREM"); // 'Terrain edge map'
// Write edge map
ostrFile->Write_t(&tr_aubEdgeMap[0],sizeof(UBYTE)*tr_pixHeightMapWidth*tr_pixHeightMapHeight);
ostrFile->WriteID_t("TEEN"); // 'Terrain edge map end'
}
(*ostrFile).WriteID_t("TRHM"); // 'Terrain heightmap'
// write height map
(*ostrFile).Write_t(&tr_auwHeightMap[0],sizeof(UWORD)*tr_pixHeightMapWidth*tr_pixHeightMapHeight);
(*ostrFile).WriteID_t("THEN"); // 'Terrain heightmap end'
(*ostrFile).WriteID_t("TRLR"); // 'Terrain layers'
// write terrain layers
INDEX cttl = tr_atlLayers.Count();
(*ostrFile)<<cttl;
for(INDEX itl=0;itl<cttl;itl++) {
CTerrainLayer &tl = tr_atlLayers[itl];
tl.Write_t(ostrFile);
}
(*ostrFile).WriteID_t("TLEN"); // 'Terrain layers end'
(*ostrFile).WriteID_t("TREN"); // 'terrain end'
}
// Copy terrain data from other terrain
void CTerrain::Copy(CTerrain &trOther)
{
ASSERT(FALSE);
}
CTerrain::~CTerrain()
{
Clear();
}
// Discard all cached shading info for models
void CTerrain::DiscardShadingInfos(void)
{
FORDELETELIST( CShadingInfo, si_lnInPolygon, tr_lhShadingInfos, itsi) {
itsi->si_penEntity->en_ulFlags &= ~ENF_VALIDSHADINGINFO;
itsi->si_lnInPolygon.Remove();
itsi->si_pbpoPolygon = NULL;
}
}
// Clear height map
void CTerrain::ClearHeightMap(void)
{
// if height map space was allocated
if(tr_auwHeightMap!=NULL) {
// release it
FreeMemory(tr_auwHeightMap);
tr_auwHeightMap = NULL;
}
}
// Clear shadow map
void CTerrain::ClearShadowMap(void)
{
// Clear current terrain shadow map
tr_tdShadowMap.Clear();
// Also clear shading map
if(tr_auwShadingMap!=NULL) {
FreeMemory(tr_auwShadingMap);
tr_auwShadingMap = NULL;
}
}
void CTerrain::ClearEdgeMap(void)
{
// if space for edge map was allocated
if(tr_aubEdgeMap!=NULL) {
// release it
FreeMemory(tr_aubEdgeMap);
tr_aubEdgeMap = NULL;
}
}
// Clear all topmaps
void CTerrain::ClearTopMaps(void)
{
// for each topmap in terrain
INDEX cttm = tr_atdTopMaps.Count();
for(INDEX itm=0;itm<cttm;itm++) {
CTextureData *ptdTopMap = &tr_atdTopMaps[0];
// Remove memory pointer cos it is shared memory
ptdTopMap->td_pulFrames = NULL;
// Clear tile topmap
ptdTopMap->Clear();
// remove topmap from container
tr_atdTopMaps.Remove(ptdTopMap);
delete ptdTopMap;
ptdTopMap = NULL;
}
tr_atdTopMaps.Clear();
ASSERT(_CrtCheckMemory());
// Remove memory pointer from global top map cos it is shared memory
tr_tdTopMap.td_pulFrames = NULL;
// Clear global topmap
tr_tdTopMap.Clear();
}
// Clear tiles
void CTerrain::ClearTiles(void)
{
// for each tile
for(INDEX itt=0;itt<tr_ctTiles;itt++) {
CTerrainTile &tt = tr_attTiles[itt];
// Clear tile
tt.Clear();
}
tr_attTiles.Clear();
tr_ctTiles = 0;
tr_ctTilesX = 0;
tr_ctTilesY = 0;
}
// Clear arrays
void CTerrain::ClearArrays(void)
{
// Clear Array holders
tr_aArrayHolders.Clear();
}
// Clear quadtree
void CTerrain::ClearQuadTree(void)
{
// Destroy quad tree nodes
tr_aqtnQuadTreeNodes.Clear();
// Clear quad tree levels
tr_aqtlQuadTreeLevels.Clear();
}
// Clear layers
void CTerrain::ClearLayers(void)
{
// Clear layers
tr_atlLayers.Clear();
}
// Clean terrain data (does not remove layers)
void CTerrain::Clean(BOOL bCleanLayers/*=TRUE*/)
{
ASSERT(FALSE);
ClearHeightMap();
ClearShadowMap();
ClearEdgeMap();
ClearTopMaps();
ClearTiles();
ClearArrays();
ClearQuadTree();
// if layers clear is required
if(bCleanLayers) {
ClearLayers();
}
}
// Clear terrain data
void CTerrain::Clear(void)
{
DiscardShadingInfos();
ClearHeightMap();
ClearShadowMap();
ClearEdgeMap();
ClearTopMaps();
ClearTiles();
ClearArrays();
ClearQuadTree();
ClearLayers();
if(tr_ptdDetailMap!=NULL) {
_pTextureStock->Release(tr_ptdDetailMap);
tr_ptdDetailMap = NULL;
}
}