929 lines
25 KiB
C++
929 lines
25 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
#include "nel/3d/zone_symmetrisation.h"
|
|
#include "nel/3d/zone.h"
|
|
#include "nel/3d/tile_bank.h"
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
// ***************************************************************************
|
|
|
|
CZoneSymmetrisation::CZoneSymmetrisation()
|
|
{
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
/*
|
|
Bit field
|
|
1-0 : state layer 0
|
|
3-2 : state layer 1
|
|
5-4 : state layer 2
|
|
7-6 : border state
|
|
9-8 : oriented border state
|
|
10 : corner flag
|
|
*/
|
|
|
|
// ***************************************************************************
|
|
|
|
CZoneSymmetrisation::TState CZoneSymmetrisation::getTileState (uint patch, uint tile, uint layer) const
|
|
{
|
|
nlassert (layer<5);
|
|
return (TState)((_TilesLayerStates[patch][tile]>>(layer*2))&0x3);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
CZoneSymmetrisation::TState CZoneSymmetrisation::getTileBorderState (uint patch, uint tile) const
|
|
{
|
|
return getTileState (patch, tile, 3);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
CZoneSymmetrisation::TState CZoneSymmetrisation::getOrientedTileBorderState (uint patch, uint tile) const
|
|
{
|
|
return getTileState (patch, tile, 4);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
bool CZoneSymmetrisation::getOrientedTileCorner (uint patch, uint tile)
|
|
{
|
|
return ( ( _TilesLayerStates[patch][tile] >> 10 ) & 1 ) != 0;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CZoneSymmetrisation::setTileState (uint patch, uint tile, uint layer, TState state)
|
|
{
|
|
uint16 &ref = _TilesLayerStates[patch][tile];
|
|
ref &= ~(3<<(layer*2));
|
|
ref |= ((uint16)state)<<(layer*2);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CZoneSymmetrisation::setTileBorderState (uint patch, uint tile, TState state)
|
|
{
|
|
setTileState (patch, tile, 3, state);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CZoneSymmetrisation::setOrientedTileBorderState (uint patch, uint tile, TState state)
|
|
{
|
|
setTileState (patch, tile, 4, state);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CZoneSymmetrisation::setOrientedTileCorner (uint patch, uint tile, bool corner)
|
|
{
|
|
uint16 &ref = _TilesLayerStates[patch][tile];
|
|
ref &= ~(1<<10);
|
|
ref |= ((uint16)corner)<<(10);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
/*
|
|
|
|
REMARKS:
|
|
- I call "isotile" the set of connected tiles in the zone using the same tileset and a continus rotation value.
|
|
|
|
This method determines the state of each tile in the zone. This state will be used to transform
|
|
the tile during symmetrisation of the zone.
|
|
|
|
The state can be Regular, Goofy or Nothing.
|
|
|
|
If the state is Nothing, this tile is in an "isotile" that is not connected to a zone border. No matter the method
|
|
you use to tranform it, it will not influence the neighbor zones.
|
|
|
|
If the state is Regular, the rotation of this tile after symmetrisation will by given by this formula : tilerot = (4-tilerot)&3
|
|
If the state is Goofy, the rotation of this tile after symmetrisation will by given by this formula : tilerot = (4-tilerot+2)&3
|
|
|
|
- Getting the state of the tile:
|
|
- A) We flag all the zone patches as Nothing.
|
|
- B) We need to select patches having an open edge on the zone border. To do so, we use the snapCell and weldThreshold
|
|
parameters.
|
|
- C) Then, for each patches on the zone border, we need to know if they are Goofy or Regular.
|
|
|
|
Y
|
|
|
|
/\
|
|
|
|
|
| 0 3
|
|
| *****
|
|
| * * This patch is regular
|
|
| * *
|
|
| *****
|
|
| 1 2
|
|
|
|
|
| 2 1
|
|
| *****
|
|
| * * This patch is regular
|
|
| * *
|
|
| *****
|
|
| 3 0
|
|
|
|
|
| 3 2
|
|
| *****
|
|
| * * This patch is goofy
|
|
| * *
|
|
| *****
|
|
| 0 1
|
|
|
|
|
| 1 4
|
|
| *****
|
|
| * * This patch is goofy
|
|
| * *
|
|
| *****
|
|
| 2 3
|
|
-----------------------------------------> X
|
|
|
|
- D) We flag each tiles as Nothing
|
|
- E) We flag each tile on an opened edge using this formula:
|
|
- If the patch is not Nothing do
|
|
- tileIsGoofy = (patchIsGoofy) XOR ((tileRotation&1) != 0)
|
|
- F) Then, we propagate the tile A flag across the tiles in the zone following this rules:
|
|
- If A is not Nothing do
|
|
- For each neighbor B of A do
|
|
- If B is different from A do
|
|
- If A is Regular (res Goofy), and B is Nothing, B will be Regular (res Goofy)
|
|
- If A is Regular (res Goofy), and B is Goofy (res Regular), -> Error
|
|
- Propagate B
|
|
*/
|
|
|
|
bool CZoneSymmetrisation::build (const std::vector<CPatchInfo> &patchInfo, float snapCell, float weldThreshold, const CTileBank &bank, CError &errorDesc, const NLMISC::CMatrix &toOriginalSpace)
|
|
{
|
|
// * Clear errors
|
|
errorDesc.Errors.clear ();
|
|
|
|
// * Build the patches state
|
|
|
|
// A) Resize arrays
|
|
_TilesLayerStates.resize (patchInfo.size ());
|
|
|
|
// D) Resize the tile array
|
|
uint i;
|
|
for (i=0; i<patchInfo.size (); i++)
|
|
{
|
|
// Ref on the patch
|
|
const CPatchInfo &patch = patchInfo[i];
|
|
_TilesLayerStates[i].resize (0);
|
|
_TilesLayerStates[i].resize (patch.OrderS * patch.OrderT, 0);
|
|
}
|
|
|
|
// B), C) and E) We need to select patches having an open edge on the zone border. To do so, we use the snapCell and weldThreshold parameters
|
|
for (i=0; i<patchInfo.size (); i++)
|
|
{
|
|
// Ref on the patch
|
|
const CPatchInfo &patch = patchInfo[i];
|
|
|
|
// Does this patch is over a border ?
|
|
TState patchState;
|
|
if (!setTileState (patch, i, snapCell, weldThreshold, patchState, toOriginalSpace, bank))
|
|
{
|
|
// Push an error
|
|
errorDesc.Errors.push_back ("Patch nb "+toString (i)+" is invalid");
|
|
}
|
|
|
|
// Set the oriented patch state
|
|
if (!setOrientedTileState (patch, i, snapCell, weldThreshold, patchState, toOriginalSpace, bank))
|
|
{
|
|
// Push an error
|
|
errorDesc.Errors.push_back ("Patch nb "+toString (i)+" is invalid");
|
|
}
|
|
}
|
|
|
|
// F) We flag each tile on an opened edge using this formula
|
|
// - If the patch is not Nothing do
|
|
// - tileIsGoofy = (patchIsGoofy) XOR ((tileRotation&1) != 0)
|
|
for (i=0; i<patchInfo.size (); i++)
|
|
{
|
|
// Ref on the patch
|
|
const CPatchInfo &patch = patchInfo[i];
|
|
|
|
// For each tile
|
|
uint s,t;
|
|
for (t=0; t<patch.OrderT; t++)
|
|
{
|
|
for (s=0; s<patch.OrderS; s++)
|
|
{
|
|
if (!propagateTileState (i, s, t, patchInfo, bank, false))
|
|
{
|
|
// Push an error
|
|
errorDesc.Errors.push_back ("Error during propagation. Topology invalid.");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// G) Force all remaining Nothing tiles to Regular
|
|
for (i=0; i<patchInfo.size (); i++)
|
|
{
|
|
// Ref on the patch
|
|
const CPatchInfo &patch = patchInfo[i];
|
|
|
|
// For each tile
|
|
uint s,t;
|
|
for (t=0; t<patch.OrderT; t++)
|
|
{
|
|
for (s=0; s<patch.OrderS; s++)
|
|
{
|
|
if (!propagateTileState (i, s, t, patchInfo, bank, true))
|
|
{
|
|
// Push an error
|
|
errorDesc.Errors.push_back ("Error during propagation. Topology invalid.");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Returns true if no error
|
|
return true; // errorDesc.Errors.size () == 0;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
bool CZoneSymmetrisation::snapOnGrid (float& value, float resolution, float snap)
|
|
{
|
|
// Calc the floor
|
|
float _floor = (float) ( resolution * floor (value / resolution) );
|
|
nlassert (_floor<=value);
|
|
|
|
// Calc the remainder
|
|
float remainder = value - _floor;
|
|
//nlassert ( (remainder>=0) && (remainder<resolution) );
|
|
|
|
// Check the snape
|
|
if ( remainder <= snap )
|
|
{
|
|
// Flag it
|
|
value = _floor;
|
|
|
|
// Floor is good
|
|
return true;
|
|
}
|
|
else if ( (resolution - remainder) <= snap )
|
|
{
|
|
// Flag it
|
|
value = _floor + resolution;
|
|
|
|
// Floor + resolution is good
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
bool CZoneSymmetrisation::setTileState (const NL3D::CPatchInfo &patch, uint patchId, float snapCell, float weldThreshold, TState &state, const NLMISC::CMatrix &toOriginalSpace, const CTileBank &bank)
|
|
{
|
|
// Edges state
|
|
TState edgesState[4] = { Nothing, Nothing, Nothing, Nothing };
|
|
|
|
// Vertices position
|
|
sint32 vertPosU[4];
|
|
sint32 vertPosV[4];
|
|
|
|
// For each vertices
|
|
uint i;
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Snap the vertex
|
|
CVector original = toOriginalSpace * patch.Patch.Vertices[i];
|
|
float valueU = original.x;
|
|
float valueV = original.y;
|
|
|
|
// Snap on U
|
|
if (snapOnGrid (valueU, snapCell, weldThreshold))
|
|
vertPosU[i] = (sint32)((valueU+0.5f) / snapCell);
|
|
else
|
|
vertPosU[i] = 0x80000000;
|
|
|
|
// Snap on V
|
|
if (snapOnGrid (valueV, snapCell, weldThreshold))
|
|
vertPosV[i] = (sint32)((valueV+0.5f) / snapCell);
|
|
else
|
|
vertPosV[i] = 0x80000000;
|
|
}
|
|
|
|
// Patch flags
|
|
bool regular = false;
|
|
bool goofy = false;
|
|
bool EdgeSnaped[4] = { false, false, false, false };
|
|
|
|
// For each edges
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Vertex snapped and align on a common axis ?
|
|
if ( ((uint32) vertPosU[i] != 0x80000000) || ((uint32) vertPosV[i] != 0x80000000) )
|
|
{
|
|
// Snapped on U or V ?
|
|
bool snapU = (vertPosU[i] == vertPosU[(i+1)&3]) && ((uint32) vertPosU[i] != 0x80000000);
|
|
bool snapV = (vertPosV[i] == vertPosV[(i+1)&3]) && ((uint32) vertPosV[i] != 0x80000000);
|
|
|
|
// If snapped on one, continue
|
|
if (snapU || snapV)
|
|
{
|
|
// If snap on the both, error
|
|
if (snapU && snapV)
|
|
return false;
|
|
|
|
// Is this edge Regular or Goofy ?
|
|
if (snapU)
|
|
edgesState[i] = (i&1)?Goofy:Regular;
|
|
else // (snapV)
|
|
edgesState[i] = (i&1)?Regular:Goofy;
|
|
|
|
// Flag the patch
|
|
if (edgesState[i] == Regular)
|
|
regular = true;
|
|
else
|
|
goofy = true;
|
|
|
|
// Edge snaped
|
|
EdgeSnaped[i] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Goofy and regular ? Error
|
|
if (goofy && regular)
|
|
return false;
|
|
|
|
// Nothing ?
|
|
if ((!goofy) && (!regular))
|
|
state = Nothing;
|
|
else
|
|
{
|
|
// Not nothing ?
|
|
state = regular?Regular:Goofy;
|
|
|
|
// * Set the tiles
|
|
|
|
// For each edges
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Edge snapped ?
|
|
if (EdgeSnaped[i])
|
|
{
|
|
// For each tiles
|
|
uint tileCount = ((i&1)!=0)?patch.OrderS:patch.OrderT;
|
|
sint currentTile;
|
|
sint delta;
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
currentTile = 0;
|
|
delta = patch.OrderS;
|
|
break;
|
|
case 1:
|
|
currentTile = patch.OrderS*(patch.OrderT-1);
|
|
delta = 1;
|
|
break;
|
|
case 2:
|
|
currentTile = patch.OrderS-1;
|
|
delta = patch.OrderS;
|
|
break;
|
|
case 3:
|
|
currentTile = 0;
|
|
delta = 1;
|
|
break;
|
|
default:
|
|
currentTile = 0;
|
|
delta = 1;
|
|
break;
|
|
}
|
|
uint j;
|
|
for (j=0; j<tileCount; j++)
|
|
{
|
|
// Set the border state
|
|
setTileBorderState (patchId, currentTile, state);
|
|
|
|
// For each layer
|
|
uint layer;
|
|
for (layer=0; layer<3; layer++)
|
|
{
|
|
// Get the tiles set used here
|
|
uint tile = patch.Tiles[currentTile].Tile[layer];
|
|
if (tile != NL_TILE_ELM_LAYER_EMPTY)
|
|
{
|
|
int tileSet;
|
|
int number;
|
|
CTileBank::TTileType type;
|
|
bank.getTileXRef (tile, tileSet, number, type);
|
|
|
|
if ((tileSet < 0) || (tileSet >= bank.getTileSetCount()))
|
|
{
|
|
nlwarning("CZoneSymmetrisation::setTileState : tile %d has an unknown tileSet (%d)", tile, tileSet);
|
|
return false;
|
|
}
|
|
|
|
// Set it only if not oriented
|
|
if (!bank.getTileSet (tileSet)->getOriented ())
|
|
{
|
|
// Set the tile state
|
|
setTileState (patchId, currentTile, layer, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next tile
|
|
currentTile += delta;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
bool CZoneSymmetrisation::setOrientedTileState (const NL3D::CPatchInfo &patch, uint patchId, float snapCell, float weldThreshold, TState &state, const NLMISC::CMatrix &toOriginalSpace, const CTileBank &bank)
|
|
{
|
|
// Edges state
|
|
TState edgesState[4] = { Nothing, Nothing, Nothing, Nothing };
|
|
|
|
// Vertices position
|
|
sint32 vertPosU[4];
|
|
sint32 vertPosV[4];
|
|
|
|
// For each vertices
|
|
uint i;
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Snap the vertex
|
|
CVector original = toOriginalSpace * patch.Patch.Vertices[i];
|
|
float valueU = original.x;
|
|
float valueV = original.y;
|
|
|
|
// Snap on U
|
|
if (snapOnGrid (valueU, snapCell, weldThreshold))
|
|
vertPosU[i] = (sint32)((valueU+0.5f) / snapCell);
|
|
else
|
|
vertPosU[i] = 0x80000000;
|
|
|
|
// Snap on V
|
|
if (snapOnGrid (valueV, snapCell, weldThreshold))
|
|
vertPosV[i] = (sint32)((valueV+0.5f) / snapCell);
|
|
else
|
|
vertPosV[i] = 0x80000000;
|
|
}
|
|
|
|
// Patch flags
|
|
bool regular = false;
|
|
bool goofy = false;
|
|
bool EdgeSnaped[4] = { false, false, false, false };
|
|
|
|
// For each edges
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Vertex snapped and align on a common axis ?
|
|
if ( ((uint32) vertPosU[i] != 0x80000000) || ((uint32) vertPosV[i] != 0x80000000) )
|
|
{
|
|
// Snapped on U or V ?
|
|
bool snapU = (vertPosU[i] == vertPosU[(i+1)&3]) && ((uint32) vertPosU[i] != 0x80000000);
|
|
bool snapV = (vertPosV[i] == vertPosV[(i+1)&3]) && ((uint32) vertPosV[i] != 0x80000000);
|
|
|
|
// If snapped on one, continue
|
|
if (snapU || snapV)
|
|
{
|
|
// If snap on the both, error
|
|
if (snapU && snapV)
|
|
return false;
|
|
|
|
// Is this edge Regular or Goofy ?
|
|
edgesState[i] = (i&1)?Goofy:Regular;
|
|
|
|
// Flag the patch
|
|
if (edgesState[i] == Regular)
|
|
regular = true;
|
|
else
|
|
goofy = true;
|
|
|
|
// Edge snaped
|
|
EdgeSnaped[i] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// * Set the tiles
|
|
|
|
// For each edges
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Edge snapped ?
|
|
if (EdgeSnaped[i])
|
|
{
|
|
// For each tiles
|
|
uint tileCount = ((i&1)!=0)?patch.OrderS:patch.OrderT;
|
|
sint currentTile;
|
|
sint delta;
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
currentTile = 0;
|
|
delta = patch.OrderS;
|
|
break;
|
|
case 1:
|
|
currentTile = patch.OrderS*(patch.OrderT-1);
|
|
delta = 1;
|
|
break;
|
|
case 2:
|
|
currentTile = patch.OrderS-1;
|
|
delta = patch.OrderS;
|
|
break;
|
|
case 3:
|
|
currentTile = 0;
|
|
delta = 1;
|
|
break;
|
|
default:
|
|
currentTile = 0;
|
|
delta = 1;
|
|
break;
|
|
}
|
|
uint j;
|
|
for (j=0; j<tileCount; j++)
|
|
{
|
|
// Set the border state
|
|
setOrientedTileBorderState (patchId, currentTile, edgesState[i]);
|
|
|
|
// For each layer
|
|
uint layer;
|
|
for (layer=0; layer<3; layer++)
|
|
{
|
|
// Get the tiles set used here
|
|
uint tile = patch.Tiles[currentTile].Tile[layer];
|
|
if (tile != NL_TILE_ELM_LAYER_EMPTY)
|
|
{
|
|
int tileSet;
|
|
int number;
|
|
CTileBank::TTileType type;
|
|
|
|
bank.getTileXRef (tile, tileSet, number, type);
|
|
if ((tileSet < 0) || (tileSet >= bank.getTileSetCount()))
|
|
{
|
|
nlwarning("CZoneSymmetrisation::setOrientedTileState : tile %d has an unknown tileSet (%d)", tile, tileSet);
|
|
return false;
|
|
}
|
|
|
|
// Set it only if oriented
|
|
if (bank.getTileSet (tileSet)->getOriented ())
|
|
{
|
|
setTileState (patchId, currentTile, layer, edgesState[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next tile
|
|
currentTile += delta;
|
|
}
|
|
}
|
|
}
|
|
|
|
// For each corners
|
|
for (i=0; i<4; i++)
|
|
{
|
|
// Corner snapped ?
|
|
uint next = (i+1)&3;
|
|
if (EdgeSnaped[i] && EdgeSnaped[next])
|
|
{
|
|
// Flag tile as corner
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
setOrientedTileCorner (patchId, patch.OrderS*(patch.OrderT-1), true);
|
|
break;
|
|
case 1:
|
|
setOrientedTileCorner (patchId, patch.OrderS*patch.OrderT-1, true);
|
|
break;
|
|
case 2:
|
|
setOrientedTileCorner (patchId, patch.OrderS-1, true);
|
|
break;
|
|
case 3:
|
|
setOrientedTileCorner (patchId, 0, true);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
CVector2f st2uv (sint s, sint t, const CPatchInfo &patch)
|
|
{
|
|
return CVector2f ((((float)s)+0.5f)/(float)patch.OrderS, (((float)t)+0.5f)/(float)patch.OrderT);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void uv2st (const CVector2f &in, sint &s, sint &t, const CPatchInfo &patch)
|
|
{
|
|
s = (sint)(in.x*(float)patch.OrderS);
|
|
t = (sint)(in.y*(float)patch.OrderT);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
class CFillStackNode
|
|
{
|
|
public:
|
|
CFillStackNode (uint16 patch, uint16 s, uint16 t, uint8 rotate, CZoneSymmetrisation::TState state) { Patch = patch; S = s; T = t; Edge = 0; Rotate = rotate; State = state; };
|
|
uint16 S;
|
|
uint16 T;
|
|
uint16 Patch;
|
|
uint8 Edge;
|
|
uint8 Rotate;
|
|
CZoneSymmetrisation::TState State;
|
|
};
|
|
|
|
// ***************************************************************************
|
|
|
|
bool CZoneSymmetrisation::propagateTileState (uint patch, uint s, uint t, const std::vector<CPatchInfo> &patchInfo, const CTileBank &bank, bool forceRegular)
|
|
{
|
|
// For each layer
|
|
uint layer;
|
|
for (layer=0; layer<3; layer++)
|
|
{
|
|
// Get the patch ptr
|
|
const CPatchInfo *currentPatchPtr = &(patchInfo[patch]);
|
|
|
|
// Get the tile index
|
|
uint tile = s+t*currentPatchPtr->OrderS;
|
|
|
|
// Get the tiles set used here
|
|
uint tileIndex = currentPatchPtr->Tiles[tile].Tile[layer];
|
|
if (tileIndex != NL_TILE_ELM_LAYER_EMPTY)
|
|
{
|
|
// Valid tile number ?
|
|
if (tileIndex >= (uint)bank.getTileCount ())
|
|
{
|
|
nlwarning ("CZoneSymmetrisation::propagateTileState: Invalid tile index");
|
|
return false;
|
|
}
|
|
|
|
// Get the tile set used by this layer
|
|
int tileSetToPropagate;
|
|
int number;
|
|
CTileBank::TTileType type;
|
|
bank.getTileXRef (tileIndex, tileSetToPropagate, number, type);
|
|
|
|
if ((tileSetToPropagate < 0) || (tileSetToPropagate >= bank.getTileSetCount()))
|
|
{
|
|
nlwarning("CZoneSymmetrisation::propagateTileState: tile %d has an unknown tileSet (%d)", tileIndex, tileSetToPropagate);
|
|
}
|
|
else
|
|
{
|
|
// Oriented ?
|
|
bool oriented = bank.getTileSet (tileSetToPropagate)->getOriented ();
|
|
|
|
// If oriented, must not be a corner
|
|
if (!(oriented && getOrientedTileCorner (patch, tile)))
|
|
{
|
|
// Current node
|
|
CFillStackNode currentNode (patch, s, t, currentPatchPtr->Tiles[tile].getTileOrient(layer), getTileState (patch, tile, layer));
|
|
|
|
// Propagate non-Nothing tiles
|
|
if ( (!forceRegular && (currentNode.State != Nothing)) || (forceRegular && (currentNode.State == Nothing)) )
|
|
{
|
|
// Force to Regular ?
|
|
if (forceRegular)
|
|
{
|
|
setTileState (patch, tile, layer, Regular);
|
|
currentNode.State = Regular;
|
|
}
|
|
|
|
// Fill stack
|
|
vector<CFillStackNode> stack;
|
|
stack.push_back (currentNode);
|
|
|
|
// While people in the stack
|
|
while (!stack.empty ())
|
|
{
|
|
// Pop last element
|
|
currentNode = stack.back ();
|
|
stack.pop_back ();
|
|
|
|
do
|
|
{
|
|
// Set current patch pointer
|
|
currentPatchPtr = &(patchInfo[currentNode.Patch]);
|
|
|
|
// Get neighbor
|
|
CFillStackNode neighborNode (currentNode.Patch, currentNode.S, currentNode.T, currentNode.Rotate, currentNode.State);
|
|
switch (currentNode.Edge)
|
|
{
|
|
case 0:
|
|
neighborNode.S--;
|
|
break;
|
|
case 1:
|
|
neighborNode.T++;
|
|
break;
|
|
case 2:
|
|
neighborNode.S++;
|
|
break;
|
|
case 3:
|
|
neighborNode.T--;
|
|
break;
|
|
}
|
|
|
|
// Is still in patch ?
|
|
if ( (neighborNode.S>=patchInfo[currentNode.Patch].OrderS) || (neighborNode.T>=patchInfo[currentNode.Patch].OrderT) )
|
|
{
|
|
// No, found new patch
|
|
uint position;
|
|
switch (currentNode.Edge)
|
|
{
|
|
case 0:
|
|
position = neighborNode.T;
|
|
break;
|
|
case 1:
|
|
position = neighborNode.S;
|
|
break;
|
|
case 2:
|
|
position = patchInfo[currentNode.Patch].OrderT - neighborNode.T - 1;
|
|
break;
|
|
case 3:
|
|
position = patchInfo[currentNode.Patch].OrderS - neighborNode.S - 1;
|
|
break;
|
|
default:
|
|
position = 0;
|
|
break;
|
|
}
|
|
|
|
// Get next patch
|
|
uint patchOut;
|
|
sint sOut;
|
|
sint tOut;
|
|
if (patchInfo[currentNode.Patch].getNeighborTile (currentNode.Patch, currentNode.Edge, position,
|
|
patchOut, sOut, tOut, patchInfo))
|
|
{
|
|
// Should be another patch
|
|
nlassert (patchOut != currentNode.Patch);
|
|
|
|
// Get patch id
|
|
neighborNode.Patch = patchOut;
|
|
|
|
// Coordinate must be IN the patch
|
|
nlassert (sOut >= 0);
|
|
nlassert (tOut >= 0);
|
|
nlassert (sOut < patchInfo[neighborNode.Patch].OrderS);
|
|
nlassert (tOut < patchInfo[neighborNode.Patch].OrderT);
|
|
|
|
// Copy it
|
|
neighborNode.S = sOut;
|
|
neighborNode.T = tOut;
|
|
|
|
// Find neighbor
|
|
const CPatchInfo::CBindInfo &neighborBindInfo = patchInfo[currentNode.Patch].BindEdges[currentNode.Edge];
|
|
uint edgePatch;
|
|
for (edgePatch=0; edgePatch<(uint)neighborBindInfo.NPatchs; edgePatch++)
|
|
{
|
|
if (neighborBindInfo.Next[edgePatch] == neighborNode.Patch)
|
|
break;
|
|
}
|
|
|
|
// Must find one patch
|
|
nlassert (edgePatch<(uint)neighborBindInfo.NPatchs);
|
|
|
|
// Rotation
|
|
neighborNode.Rotate = (currentNode.Rotate + 2 + neighborBindInfo.Edge[edgePatch] - currentNode.Edge) & 3;
|
|
|
|
// Toggle the state ?
|
|
if ((neighborNode.Rotate ^ currentNode.Rotate) & 1)
|
|
{
|
|
// Yes
|
|
neighborNode.State = (neighborNode.State == Regular) ? Goofy : Regular;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No propagation, continue
|
|
currentNode.Edge++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Neighbor patch
|
|
const CPatchInfo *neighborPatchPtr = &(patchInfo[neighborNode.Patch]);
|
|
|
|
// Get the tile index
|
|
uint neighborTile = neighborNode.S+neighborNode.T*neighborPatchPtr->OrderS;
|
|
|
|
// Look for the same tile set in the new tile
|
|
uint neighborLayer;
|
|
for (neighborLayer=0; neighborLayer<3; neighborLayer++)
|
|
{
|
|
// Get the tile index
|
|
uint neighborTileIndex = neighborPatchPtr->Tiles[neighborTile].Tile[neighborLayer];
|
|
|
|
if (neighborTileIndex != NL_TILE_ELM_LAYER_EMPTY)
|
|
{
|
|
// Valid tile number ?
|
|
if (neighborTileIndex >= (uint)bank.getTileCount ())
|
|
{
|
|
nlwarning ("CZoneSymmetrisation::propagateTileState: Invalid tile index");
|
|
return false;
|
|
}
|
|
|
|
// Get tileset
|
|
int neighborTileSet;
|
|
int neighborNumber;
|
|
CTileBank::TTileType neighborType;
|
|
bank.getTileXRef (neighborTileIndex, neighborTileSet, neighborNumber, neighborType);
|
|
|
|
// Same tileset ? Stop!
|
|
if ( (neighborTileSet == tileSetToPropagate) &&
|
|
(neighborNode.Rotate == neighborPatchPtr->Tiles[neighborTile].getTileOrient(neighborLayer)) )
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Found ?
|
|
if (neighborLayer<3)
|
|
{
|
|
// If oriented, must not be a corner
|
|
if (!(oriented && getOrientedTileCorner (neighborNode.Patch, neighborTile)))
|
|
{
|
|
// Propagate in the new node ?
|
|
TState neighborState = getTileState (neighborNode.Patch, neighborTile, neighborLayer);
|
|
if (neighborState == Nothing)
|
|
{
|
|
// Set the state
|
|
setTileState (neighborNode.Patch, neighborTile, neighborLayer, neighborNode.State);
|
|
|
|
// Stack current node if some neighbor left to visit
|
|
if (currentNode.Edge < 3)
|
|
{
|
|
currentNode.Edge++;
|
|
stack.push_back (currentNode);
|
|
}
|
|
|
|
// Continue with the new node
|
|
currentNode = neighborNode;
|
|
}
|
|
else if (neighborState != neighborNode.State)
|
|
{
|
|
// Error, same tile but not same state
|
|
// nlwarning ("CZoneSymmetrisation::propagateTileState: error, find same iso surfaces with different state.");
|
|
|
|
// No propagation, continue
|
|
currentNode.Edge++;
|
|
}
|
|
else
|
|
{
|
|
// No propagation, continue
|
|
currentNode.Edge++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No propagation, continue
|
|
currentNode.Edge++;
|
|
}
|
|
}
|
|
else
|
|
// No propagation, continue
|
|
currentNode.Edge++;
|
|
}
|
|
while (currentNode.Edge<4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
} // NL3D
|