NL3D::CZoneSymmetrisation Class Reference

#include <zone_symmetrisation.h>

---

Detailed Description

Environnement used to symmetrise zones

This class build symmetry specific informations needed to know how transform tiles when a zone is symmetrise.

There is two states for a tile : Regular or Goofy. If the tile is regular, it doesn't need specific transformation when the zone is symmetrise. If the tile is goofy, the tile must be rotate by 180deg more to be correct.

Author:

Cyril 'Hulud' Corvazier

Nevrax France

Date:

2002

Definition at line 54 of file zone_symmetrisation.h.

Public Types
enum	TState { Nothing = 0, Regular = 1, Goofy = 2 }
	Symmetrie state. More...
Public Member Functions
bool	build (const std::vector< CPatchInfo > &patchInfo, float snapCell, float weldThreshold, const CTileBank &bank, CError &errorDesc, const NLMISC::CMatrix &toOriginalSpace)
	CZoneSymmetrisation ()
	Constructor.
TState	getOrientedTileBorderState (uint patch, uint tile) const
bool	getOrientedTileCorner (uint patch, uint tile)
TState	getTileBorderState (uint patch, uint tile) const
TState	getTileState (uint patch, uint tile, uint layer) const
Private Member Functions
bool	propagateTileState (uint i, uint s, uint t, const std::vector< CPatchInfo > &patchInfo, const CTileBank &bank, bool forceRegular)
void	setOrientedTileBorderState (uint patch, uint tile, TState state)
void	setOrientedTileCorner (uint patch, uint tile, bool corner)
bool	setOrientedTileState (const NL3D::CPatchInfo &patch, uint patchId, float snapCell, float weldThreshold, TState &state, const NLMISC::CMatrix &toOriginalSpace, const CTileBank &bank)
void	setTileBorderState (uint patch, uint tile, TState state)
bool	setTileState (const NL3D::CPatchInfo &patch, uint patchId, float snapCell, float weldThreshold, TState &state, const NLMISC::CMatrix &toOriginalSpace, const CTileBank &bank)
void	setTileState (uint patch, uint tile, uint layer, TState state)
Static Private Member Functions
bool	snapOnGrid (float &value, float resolution, float snap)
Private Attributes
std::vector< std::vector< uint16 > >	_TilesLayerStates

---

Member Enumeration Documentation

enum NL3D::CZoneSymmetrisation::TState

Symmetrie state. Enumeration values: Nothing  Regular  Goofy  Definition at line 59 of file zone_symmetrisation.h. { Nothing =0, Regular =1, Goofy =2, };

---

Constructor & Destructor Documentation

NL3D::CZoneSymmetrisation::CZoneSymmetrisation (   )

Constructor. Definition at line 39 of file zone_symmetrisation.cpp. { }

---

Member Function Documentation

bool NL3D::CZoneSymmetrisation::build (  const std::vector< CPatchInfo > &  patchInfo, float  snapCell, float  weldThreshold, const CTileBank &  bank, CError &  errorDesc, const NLMISC::CMatrix &  toOriginalSpace )

Build symmetry informations Parameters: zone  is the zone to build symmetry informations snapCell  is the unit size of the zones weldThreshold  is the threshold used to check vertex over snaped positions errorDesc  is a structure used to return errors toOriginalSpace  is the matrix used to transform back a vertex in its original position before symmetry / rotation Returns: false if the patch topology is invalid for this operations Definition at line 186 of file zone_symmetrisation.cpp. References _TilesLayerStates, NL3D::CZoneSymmetrisation::CError::Errors, NL3D::CPatchInfo::OrderS, NL3D::CPatchInfo::OrderT, propagateTileState(), s, setOrientedTileState(), setTileState(), t, NLMISC::toString(), and uint. Referenced by NL3D::CPatchInfo::transform(). { // * 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; }

CZoneSymmetrisation::TState NL3D::CZoneSymmetrisation::getOrientedTileBorderState (  uint  patch, uint  tile )  const

Get tile symmetry state for oriented tiles Can return Regular, Goofy or Nothing. Definition at line 72 of file zone_symmetrisation.cpp. References getTileState(), and uint. { return getTileState (patch, tile, 4); }

bool NL3D::CZoneSymmetrisation::getOrientedTileCorner (  uint  patch, uint  tile )

Set oriented tile corner state Definition at line 79 of file zone_symmetrisation.cpp. References _TilesLayerStates, and uint. Referenced by propagateTileState(). { return ( ( _TilesLayerStates[patch][tile] >> 10 ) & 1 ) != 0; }

CZoneSymmetrisation::TState NL3D::CZoneSymmetrisation::getTileBorderState (  uint  patch, uint  tile )  const

Get tile symmetry state Can return Regular, Goofy or Nothing. Definition at line 65 of file zone_symmetrisation.cpp. References getTileState(), and uint. { return getTileState (patch, tile, 3); }

CZoneSymmetrisation::TState NL3D::CZoneSymmetrisation::getTileState (  uint  patch, uint  tile, uint  layer )  const

Get tile symmetry state Can return Regular, Goofy or Nothing. Definition at line 57 of file zone_symmetrisation.cpp. References _TilesLayerStates, nlassert, and uint. Referenced by getOrientedTileBorderState(), getTileBorderState(), propagateTileState(), and NL3D::CPatchInfo::transform(). { nlassert (layer<5); return (TState)((_TilesLayerStates[patch][tile]>>(layer*2))&0x3); }

bool NL3D::CZoneSymmetrisation::propagateTileState (  uint  i, uint  s, uint  t, const std::vector< CPatchInfo > &  patchInfo, const CTileBank &  bank, bool  forceRegular )  [private]

Propagate tile state information for a given tile. Parameters: i  is the patch number in the zone that contain the tile to propagate u  is the tile u coordinate in the patch v  is the tile v coordinate in the patch patchInfo  is a vector of patch information bank  is the tile bank used by the landscape forceRegular  must be true to force the first propagated tile to Regular if Nothing Returns: false if the patch topology is invalid for this operations true if succesful Definition at line 670 of file zone_symmetrisation.cpp. References NL3D::CPatchInfo::CBindInfo::Edge, NL3D::CFillStackNode::Edge, NL3D::CTileSet::getOriented(), getOrientedTileCorner(), NL3D::CTileBank::getTileCount(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileSetCount(), getTileState(), NL3D::CTileBank::getTileXRef(), Goofy, NL3D::CPatchInfo::CBindInfo::Next, NL_TILE_ELM_LAYER_EMPTY, nlassert, nlwarning, Nothing, NL3D::CPatchInfo::CBindInfo::NPatchs, NL3D::CPatchInfo::OrderS, NL3D::CFillStackNode::Patch, Regular, NL3D::CFillStackNode::Rotate, NL3D::CFillStackNode::S, s, setTileState(), sint, NL3D::CFillStackNode::State, NL3D::CFillStackNode::T, t, NL3D::CPatchInfo::Tiles, type, and uint. Referenced by build(). { // 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; } // 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; }

void NL3D::CZoneSymmetrisation::setOrientedTileBorderState (  uint  patch, uint  tile, TState  state )  [private]

Set border oriented tile symmetry state Definition at line 102 of file zone_symmetrisation.cpp. References setTileState(), and uint. Referenced by setOrientedTileState(). { setTileState (patch, tile, 4, state); }

void NL3D::CZoneSymmetrisation::setOrientedTileCorner (  uint  patch, uint  tile, bool  corner )  [private]

Set oriented tile corner state Definition at line 109 of file zone_symmetrisation.cpp. References _TilesLayerStates, uint, and uint16. Referenced by setOrientedTileState(). { uint16 &ref = _TilesLayerStates[patch][tile]; ref &= ~(1<<10); ref |= ((uint16)corner)<<(10); }

bool NL3D::CZoneSymmetrisation::setOrientedTileState (  const NL3D::CPatchInfo &  patch, uint  patchId, float  snapCell, float  weldThreshold, TState &  state, const NLMISC::CMatrix &  toOriginalSpace, const CTileBank &  bank )  [private]

Definition at line 472 of file zone_symmetrisation.cpp. References NL3D::CTileSet::getOriented(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileSetCount(), NL3D::CTileBank::getTileXRef(), Goofy, NL_TILE_ELM_LAYER_EMPTY, nlwarning, Nothing, NL3D::CPatchInfo::OrderS, NL3D::CPatchInfo::OrderT, NL3D::CPatchInfo::Patch, Regular, setOrientedTileBorderState(), setOrientedTileCorner(), setTileState(), sint, sint32, snapOnGrid(), NL3D::CPatchInfo::Tiles, type, uint, NL3D::CBezierPatch::Vertices, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by build(). { // 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 ( (vertPosU[i] != 0x80000000) || (vertPosV[i] != 0x80000000) ) { // Snapped on U or V ? bool snapU = (vertPosU[i] == vertPosU[(i+1)&3]) && (vertPosU[i] != 0x80000000); bool snapV = (vertPosV[i] == vertPosV[(i+1)&3]) && (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; } 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; }

void NL3D::CZoneSymmetrisation::setTileBorderState (  uint  patch, uint  tile, TState  state )  [private]

Set border tile symmetry state Definition at line 95 of file zone_symmetrisation.cpp. References setTileState(), and uint. Referenced by setTileState(). { setTileState (patch, tile, 3, state); }

bool NL3D::CZoneSymmetrisation::setTileState (  const NL3D::CPatchInfo &  patch, uint  patchId, float  snapCell, float  weldThreshold, TState &  state, const NLMISC::CMatrix &  toOriginalSpace, const CTileBank &  bank )  [private]

Set tile state of a patch Definition at line 312 of file zone_symmetrisation.cpp. References NL3D::CTileSet::getOriented(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileSetCount(), NL3D::CTileBank::getTileXRef(), Goofy, NL_TILE_ELM_LAYER_EMPTY, nlwarning, Nothing, NL3D::CPatchInfo::OrderS, NL3D::CPatchInfo::OrderT, NL3D::CPatchInfo::Patch, Regular, setTileBorderState(), setTileState(), sint, sint32, snapOnGrid(), NL3D::CPatchInfo::Tiles, type, uint, NL3D::CBezierPatch::Vertices, NLMISC::CVector::x, and NLMISC::CVector::y. { // 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 ( (vertPosU[i] != 0x80000000) || (vertPosV[i] != 0x80000000) ) { // Snapped on U or V ? bool snapU = (vertPosU[i] == vertPosU[(i+1)&3]) && (vertPosU[i] != 0x80000000); bool snapV = (vertPosV[i] == vertPosV[(i+1)&3]) && (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; } 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; }

void NL3D::CZoneSymmetrisation::setTileState (  uint  patch, uint  tile, uint  layer, TState  state )  [private]

Set orientedtile symmetry state Definition at line 86 of file zone_symmetrisation.cpp. References _TilesLayerStates, uint, and uint16. Referenced by build(), propagateTileState(), setOrientedTileBorderState(), setOrientedTileState(), setTileBorderState(), and setTileState(). { uint16 &ref = _TilesLayerStates[patch][tile]; ref &= ~(3<<(layer*2)); ref |= ((uint16)state)<<(layer*2); }

bool NL3D::CZoneSymmetrisation::snapOnGrid (  float &  value, float  resolution, float  snap )  [static, private]

Definition at line 280 of file zone_symmetrisation.cpp. References nlassert, and value. Referenced by setOrientedTileState(), and setTileState(). { // 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; }

---

Field Documentation

std::vector<std::vector<uint16> > NL3D::CZoneSymmetrisation::_TilesLayerStates [private]

Definition at line 158 of file zone_symmetrisation.h. Referenced by build(), getOrientedTileCorner(), getTileState(), setOrientedTileCorner(), and setTileState().

---

The documentation for this class was generated from the following files:

• zone_symmetrisation.h
• zone_symmetrisation.cpp

---